@seeka-labs/cli-apps 3.8.1 → 3.8.5

package/README.md

@@ -12,7 +12,7 @@ npm install -g @seeka-labs/cli-apps
 yarn global add @seeka-labs/cli-apps
 
 # Or run directly with npx
-npx @seeka-labs/cli-apps
+npx @seeka-labs/cli-apps@latest
 ```
 
 ## Quick Start
@@ -20,7 +20,7 @@ npx @seeka-labs/cli-apps
 The fastest way to get started is to run the CLI without any arguments to enter **interactive mode**:
 
 ```bash
-npx @seeka-labs/cli-apps
+npx @seeka-labs/cli-apps@latest
 ```
 
 This will guide you through the setup process with prompts for all required information.
@@ -35,13 +35,13 @@ Creates a new Seeka app with the specified template and configuration.
 
 ```bash
 # Interactive mode (recommended for first-time users)
-npx @seeka-labs/cli-apps
+npx @seeka-labs/cli-apps@latest
 
 # Using command-line arguments
-npx @seeka-labs/cli-apps init <org> <name> [options]
+npx @seeka-labs/cli-apps@latest init <org> <name> [options]
 
 # Using a configuration file
-npx @seeka-labs/cli-apps init <config-file.json>
+npx @seeka-labs/cli-apps@latest init <config-file.json>
 ```
 
 #### Arguments
@@ -71,27 +71,27 @@ npx @seeka-labs/cli-apps init <config-file.json>
 
 ```bash
 # Create a new Azure Function app
-npx @seeka-labs/cli-apps init my-org my-app \
+npx @seeka-labs/cli-apps@latest init my-org my-app \
   --template azure-function \
   --developer "My Company" \
   --email "dev@mycompany.com"
 
 # Create app with environment variables
-npx @seeka-labs/cli-apps init my-org my-app \
+npx @seeka-labs/cli-apps@latest init my-org my-app \
   --template azure-function \
   --developer "My Company" \
   --email "dev@mycompany.com" \
   --env "SEEKA_APP_ID=your-app-id" "SEEKA_APP_SECRET=your-secret"
 
 # Create app without installing dependencies
-npx @seeka-labs/cli-apps init my-org my-app \
+npx @seeka-labs/cli-apps@latest init my-org my-app \
   --template azure-function \
   --developer "My Company" \
   --email "dev@mycompany.com" \
   --noDependencies
 
 # Create app from a configuration file
-npx @seeka-labs/cli-apps init ./my-app-config.json
+npx @seeka-labs/cli-apps@latest init ./my-app-config.json
 ```
 
 ---
@@ -104,10 +104,10 @@ Installs AI context files to help AI assistants understand your Seeka app struct
 
 ```bash
 # Install AI context to current directory
-npx @seeka-labs/cli-apps ai context
+npx @seeka-labs/cli-apps@latest ai context
 
 # Install AI context to a specific directory
-npx @seeka-labs/cli-apps ai context --target /path/to/project
+npx @seeka-labs/cli-apps@latest ai context --target /path/to/project
 ```
 
 #### Options
@@ -151,7 +151,7 @@ npx @seeka-labs/cli-apps ai context --target /path/to/project
 When you run the CLI without any arguments, it enters interactive mode:
 
 ```bash
-npx @seeka-labs/cli-apps
+npx @seeka-labs/cli-apps@latest
 ```
 
 ### Available Actions
@@ -198,7 +198,7 @@ You can use a JSON configuration file instead of command-line arguments:
 Then run:
 
 ```bash
-npx @seeka-labs/cli-apps init ./my-config.json
+npx @seeka-labs/cli-apps@latest init ./my-config.json
 ```
 
 ---

package/dist/ai-context/internal/examples/_index.md

@@ -6,7 +6,7 @@ This index provides an overview of all available example apps that can be used a
 
 - **Total Examples**: 19
 - **Template Versions**: V3, V2, V1
-- **Last Updated**: 2026-01-16
+- **Last Updated**: 2026-01-17
 
 ## Quick Reference by Category
 

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

@@ -1,43 +1,46 @@
-# AI Summary for Seeka App: ActiveCampaign
-
-## Overview
-The Seeka app "activecampaign" is designed to integrate with ActiveCampaign CRM for syncing contacts and activity data. It leverages Azure Functions to handle webhooks and manage state with Redis, providing a seamless connection between Seeka and ActiveCampaign.
+# AI Summary for Seeka App: ActiveCampaign Integration
 
 ## Purpose and Functionality
-- **Integration with ActiveCampaign CRM:** The app syncs contact and activity data between Seeka and ActiveCampaign.
-- **Webhook Handling:** Processes various webhook events such as app installation, uninstallation, and activity acceptance.
-- **State Management:** Uses Redis to manage installation states and other necessary data.
+
+The Seeka app `activecampaign` is designed to integrate with ActiveCampaign CRM to sync contacts and activity data. It facilitates the management of CRM data by handling webhooks from Seeka and performing operations such as installing, updating, and uninstalling apps, as well as processing activity data.
 
 ## Key Implementation Patterns
-- **Azure Functions:** Utilized for serverless execution of webhook handlers and health checks.
-- **TypeScript:** The app is built using TypeScript, providing type safety and modern JavaScript features.
-- **Winston Logging:** Integrated for logging and debugging purposes, with support for Seq logging.
+
+- **Azure Functions**: The app is built using Azure Functions, which allows it to handle HTTP requests and perform serverless operations.
+- **Webhook Handling**: The app processes various webhook events from Seeka, such as app installation, settings updates, and activity acceptance.
+- **State Management**: Redis is used for storing installation states, which can be managed using the `@seeka-labs/sdk-apps-server`.
 
 ## External APIs/Services Integrated
-- **ActiveCampaign API:** For managing contacts and pipelines within the ActiveCampaign CRM.
-- **Azure Storage:** Used for queue management and other storage needs.
-- **Redis via Upstash:** For state management and caching.
-- **Ngrok:** Allows local development by exposing the app to the internet for testing.
+
+- **ActiveCampaign API**: The app interacts with ActiveCampaign for managing contacts and pipeline deals.
+- **Azure Services**: Utilizes Azure Storage for queues, blobs, and tables, and Azure Functions for serverless execution.
+- **Upstash Redis**: Optionally used for state management, providing a scalable Redis instance.
 
 ## Important Data Transformations
-- **Contact and Activity Data:** Transforms Seeka identity data to ActiveCampaign contact format using utility functions.
-- **Webhook Payloads:** Parses and validates incoming webhook payloads to ensure they are processed correctly.
+
+- **Contact Management**: Transforms Seeka identity data into ActiveCampaign contact data using functions like `seekaIdentityToActiveCampaignContact`.
+- **Pipeline Management**: Maps and maintains pipelines in ActiveCampaign, ensuring deals are created and updated appropriately.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation:** Ensures security by validating webhook signatures before processing.
-- **Service Initialization:** Uses a `startServices` function to initialize necessary services before handling webhooks.
-- **Error Handling:** Implements try-catch blocks to handle errors gracefully and log them using Winston.
-- **State Management with Redis:** Provides a reusable pattern for managing application state in a distributed environment.
 
-## Deployment and Development
-- **Azure Functions Deployment:** The app is configured for deployment to Azure Functions, supporting both local and cloud environments.
-- **Local Development with Docker:** Uses Azurite for local emulation of Azure Storage services.
-- **VSCode Debugging:** Supports debugging with breakpoints, primarily tested on Linux with WSL support for Windows.
+- **Webhook Signature Validation**: Ensures secure processing of webhooks by validating signatures using `throwOnInvalidWebhookSignature`.
+- **Service Initialization**: Uses a `startServices` function to initialize necessary services before processing webhooks.
+- **Error Handling**: Implements robust error handling with logging using Winston, capturing detailed error information for debugging.
+
+## Development and Deployment
+
+- **Local Development**: Supports local development with Azure Storage emulation using Azurite and local debugging via VSCode.
+- **Deployment**: Ready for deployment to Azure Functions, with instructions for setting up environment variables and using GitLab for CI/CD.
+- **Ngrok Integration**: Allows local testing by exposing the app to the internet using Ngrok.
+
+## Logging and Monitoring
+
+- **Winston and Seq**: Integrated for logging, providing structured and centralized logging capabilities.
 
 ## References
+
 - [Azure Functions Documentation](https://learn.microsoft.com/en-us/azure/azure-functions/)
-- [ActiveCampaign API Documentation](https://developers.activecampaign.com/)
-- [Ngrok Documentation](https://ngrok.com/docs)
-- [Redis with Upstash](https://upstash.com/)
+- [Azure Storage Quickstart](https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-nodejs)
+- [Ngrok Setup](https://ngrok.com/docs)
 
-This summary provides an AI-friendly overview of the Seeka app's architecture, key features, and integration points, facilitating better understanding and interaction with the app's implementation.
+This summary provides an overview of the Seeka app's architecture and functionality, highlighting key patterns and integrations that can be referenced for similar implementations.

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

@@ -1,34 +1,36 @@
 # AI Summary for Seeka App: Complianz
 
-## Purpose and Functionality
+## Overview
+The Complianz app is a Seeka application designed to integrate consent management for GDPR and privacy compliance. It utilizes Azure Functions to handle webhooks and manage state, ensuring that user consent is properly managed and logged. The app is structured to facilitate easy deployment and development, leveraging several external services and libraries.
 
-The "Complianz" app is designed to integrate consent management for GDPR and privacy compliance into Seeka applications. It facilitates the handling of user consent and privacy settings, ensuring that applications comply with regulatory requirements. The app is built using Azure Functions, providing serverless execution of its components.
+## Purpose and Functionality
+- **GDPR Compliance**: Manages user consent in compliance with GDPR regulations.
+- **Webhook Handling**: Processes inbound webhooks from Seeka to manage app installations and updates.
+- **State Management**: Utilizes Redis for storing app installation states and other necessary data.
+- **Logging**: Implements centralized logging using Winston and Seq for monitoring and debugging.
 
 ## Key Implementation Patterns
-
-1. **Azure Functions**: The app leverages Azure Functions to handle HTTP requests and manage asynchronous operations such as webhooks and queue processing.
-2. **Webhook Handling**: The app processes incoming webhooks from Seeka, validating signatures and managing installation states.
-3. **Queue Management**: Implements Azure Storage Queues for handling long-running operations asynchronously, ensuring compliance with Azure Function execution limits.
-4. **Polling Mechanism**: Utilizes scheduled functions to perform regular checks or operations, distributing workload over time.
+- **Azure Functions**: The app is built on Azure Functions, allowing for scalable and event-driven execution.
+- **Webhook Processing**: Handles different types of webhook calls (e.g., installation, update, uninstallation) with validation and logging.
+- **Queue and Polling**: Uses Azure storage queues for offloading long-running tasks and scheduled polling for periodic operations.
 
 ## External APIs/Services Integrated
-
-1. **Azure Functions**: Used for deploying and executing serverless functions.
-2. **Azure Storage**: Employed for queue management and storage emulation during development.
-3. **Ngrok**: Facilitates local development by exposing the app to the internet for testing.
-4. **Seq and Winston**: Integrated for centralized logging and monitoring of application events.
-5. **Redis**: Used for state management, storing installation data and other necessary state information.
+- **Azure Functions**: Core execution environment for serverless functions.
+- **Redis**: Used for state management, with optional integration with Upstash for cloud-hosted Redis instances.
+- **Seq and Winston**: Integrated for logging, providing a robust solution for tracking and analyzing logs.
+- **Ngrok**: Utilized for exposing local development environments to the internet for testing purposes.
 
 ## Important Data Transformations
-
-- **Webhook Payload Processing**: The app parses and validates JSON payloads from incoming webhooks, ensuring data integrity and security through signature validation.
-- **State Management**: Transforms and stores installation data using Redis, allowing for efficient retrieval and updates.
+- **Webhook Payloads**: Parses and validates webhook payloads to ensure data integrity and proper processing.
+- **State Management**: Transforms installation data for storage and retrieval in Redis, ensuring consistency across app states.
 
 ## Notable Code Patterns
+- **Modular Function Design**: Each function is designed to handle specific tasks, such as `seekaAppWebhook` for webhook processing and `healthCheck` for application health monitoring.
+- **Error Handling and Logging**: Comprehensive error handling with detailed logging using Winston, ensuring that issues are tracked and resolved efficiently.
+- **Environment Configuration**: Utilizes environment variables for configuration, supporting flexible deployment across different environments.
 
-1. **Centralized Logging**: Utilizes Winston for logging, with optional Seq integration for enhanced log management and analysis.
-2. **State Management with Redis**: Provides a flexible and scalable approach to manage application state, with the option to replace Redis with other providers.
-3. **Error Handling**: Implements robust error handling in webhook processing to ensure graceful degradation and informative logging.
-4. **Environment Configuration**: Supports development and production environments with configurable settings for Azure and Redis connections.
+## Development and Deployment
+- **Local Development**: Supports local development with Docker and Ngrok for testing Azure storage and exposing local servers.
+- **Continuous Deployment**: Scripts for building, testing, and deploying the app to Azure, ensuring a streamlined CI/CD process.
 
-This summary provides an overview of the "Complianz" app's architecture and implementation, highlighting its integration with Azure services and its focus on privacy compliance. The app's design patterns and external integrations make it a robust solution for managing GDPR consent within Seeka applications.
+This summary provides an overview of the Complianz app's architecture and functionality, highlighting key aspects that AI assistants can leverage for understanding and referencing the app's implementation patterns.

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

@@ -1,32 +1,32 @@
 # AI Summary for Seeka App - iVvy
 
-## Purpose and Functionality
-The iVvy app is designed to integrate with the iVvy venue management system, enabling users to track event bookings and inquiries. This app is particularly useful for managing events, venue bookings, and hospitality services.
+## Overview
+The Seeka app "iVvy" is designed to integrate with the iVvy venue management platform, focusing on tracking event bookings and inquiries. It is built using the Azure Functions template and includes server-side components. The app is tailored for the events and hospitality industry, providing seamless venue management capabilities.
 
 ## Key Implementation Patterns
-- **Azure Functions Deployment**: The app is structured to be deployed as an Azure Function, leveraging serverless architecture for scalability and cost-effectiveness.
-- **AWS Lambda Integration**: The app can also be deployed on AWS Lambda, allowing flexibility in cloud service providers.
-- **State Management with Redis**: The app uses Redis, hosted by Upstash, for managing state, such as installations and other persistent data.
+- **Serverless Architecture**: The app is designed to run on Azure Functions, leveraging serverless computing for scalability and cost-effectiveness.
+- **TypeScript and Node.js**: The app is developed using TypeScript, compiled to Node.js, ensuring type safety and modern JavaScript features.
+- **Continuous Integration/Continuous Deployment (CI/CD)**: Utilizes scripts for building, packaging, and deploying to AWS Lambda, facilitating automated deployment processes.
 
 ## External APIs/Services Integrated
-- **iVvy API**: The core integration is with the iVvy venue management system, although specific API endpoints are not detailed in the provided files.
+- **iVvy API**: The app integrates with the iVvy platform to manage venue bookings and inquiries.
+- **AWS Lambda**: Used for deploying the serverless function, allowing for scalable execution of the app.
+- **Redis via Upstash**: Provides state management for installations and other application states.
 - **Ngrok**: Used for exposing local development environments to the internet for testing purposes.
-- **AWS Lambda and Azure Functions**: Both platforms are supported for deploying the serverless function.
-- **Upstash Redis**: Used for state management, providing a cloud-based Redis instance.
 
 ## Important Data Transformations
-- **State Management**: The app manages installation states and other data using Redis, which involves serializing and deserializing data for storage and retrieval.
-- **Environment Configuration**: The app uses environment variables for configuration, which are managed in AWS Lambda or Azure Functions settings.
+- **State Management**: Utilizes Redis to store and manage application state, particularly for installations. This involves serializing and deserializing state data for efficient storage and retrieval.
+- **API Requests and Responses**: The app likely transforms data between the iVvy API and the internal application logic, ensuring compatibility and correct data handling.
 
 ## Notable Code Patterns
-- **Serverless Express**: The app uses `@codegenie/serverless-express` to handle HTTP requests in a serverless environment, allowing Express.js applications to run on AWS Lambda.
-- **Logging with Winston and Seq**: Although not fully implemented, the app includes logging capabilities using Winston and Seq for structured logging.
-- **TypeScript and Esbuild**: The app is built using TypeScript, with `esbuild` used for bundling and transpiling the TypeScript code.
-- **Development and Debugging**: The app supports development workflows with tools like `nodemon` for live-reloading and VSCode debugging configurations.
+- **Environment Configuration**: Uses environment variables extensively for configuration, supporting different environments (development, production).
+- **Logging**: Integrates Winston and Seq for logging, although specific implementations are marked as TODO.
+- **Debugging Support**: Provides robust debugging capabilities using VSCode, with configurations for breakpoints and live debugging.
+- **Build and Deployment Scripts**: Comprehensive scripts for building, cleaning, and deploying the app, including AWS CLI integration for Lambda deployment.
 
-## Development and Deployment
-- **Development Tools**: The app uses `yarn` for package management, `eslint` for linting, and `ts-node` for running TypeScript directly.
-- **Deployment Scripts**: The app includes scripts for building and deploying to AWS Lambda and Azure Functions, with specific instructions for setting up and deploying the app.
-- **Environment Management**: `.env` files are used for managing environment variables, with examples provided for required configurations.
+## Deployment and State Management
+- **Azure Functions and AWS Lambda**: The app is designed to be deployed on Azure Functions but also supports deployment on AWS Lambda, providing flexibility in cloud provider choice.
+- **Redis State Management**: State is managed using Redis, with Upstash as an optional provider, offering a scalable and reliable state management solution.
 
-This summary provides an overview of the iVvy app's architecture, integrations, and development patterns, which can be useful for AI assistants in understanding and referencing the app's implementation.
+## Conclusion
+The Seeka app "iVvy" is a robust solution for venue management, leveraging modern cloud technologies and development practices. Its integration with iVvy and use of serverless architecture make it a scalable and efficient tool for managing event bookings and inquiries. The app's design patterns and deployment strategies offer valuable insights for similar applications in the events and hospitality domain.

package/dist/ai-context/internal/examples/v1/me-and-u-connect/_ai-summary.md

@@ -1,29 +1,40 @@
-# AI Summary for Me&u Connect App
+# AI Summary for Me&u Connect Seeka App
+
+## Overview
+
+The **Me&u Connect** Seeka app integrates mobile ordering and payment tracking functionalities specifically for the hospitality industry, such as restaurants. It leverages Azure Functions to handle webhooks and background jobs, providing a seamless connection between mobile ordering systems and CRM capabilities.
 
 ## Purpose and Functionality
-The "Me&u Connect" app is designed for integration with mobile ordering and payment tracking systems in the hospitality industry. It facilitates seamless interactions between restaurant services and customer management systems, enabling efficient order processing and payment tracking.
+
+- **Mobile Ordering Integration**: Facilitates mobile ordering for hospitality businesses.
+- **Payment Tracking**: Tracks payments made through the app.
+- **CRM Integration**: Connects with Me&u CRM to manage customer data and interactions.
+- **Webhook Handling**: Processes various webhook events related to app installation, updates, and identity changes.
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is built using Azure Functions, allowing for serverless execution of code in response to events such as HTTP requests and queue messages.
-- **Event-Driven Architecture**: Utilizes webhooks and storage queues to handle asynchronous events and background jobs, ensuring scalable and responsive operations.
-- **State Management**: Employs Redis for managing application state, particularly for installation data, which can be swapped with other state providers if needed.
+
+- **Azure Functions**: Utilizes Azure Functions to handle HTTP requests, timers, and storage queues. This serverless architecture allows for scalable and efficient processing of events and background jobs.
+- **Background Jobs**: Implements background job processing using Azure Storage Queues to manage tasks like contact synchronization.
+- **State Management**: Uses Redis for managing application state, such as installations and configurations.
+- **Logging**: Employs Winston for logging, with plans to integrate Seq for structured logging.
 
 ## External APIs/Services Integrated
-- **Azure Storage**: Used for queue management, enabling the app to handle background tasks and inter-process communication.
-- **Redis (Upstash)**: Provides a cloud-based Redis instance for state management, particularly for storing installation states.
-- **Ngrok**: Facilitates local development by exposing the app to the internet, allowing for testing of webhooks and remote interactions.
+
+- **Azure Storage**: Uses Azure Storage Queues for background job processing and Azurite for local development emulation.
+- **Redis**: Utilizes Redis, optionally hosted by Upstash, for state management.
+- **Ngrok**: Provides local development support by exposing the app to the internet for testing purposes.
+- **Seeka SDK**: Integrates with the Seeka SDK for handling webhook payloads and managing app installations.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: The app processes various types of webhook payloads, such as installation, uninstallation, and identity changes, transforming them into actionable tasks within the system.
-- **Queue Message Handling**: Transforms incoming queue messages into structured tasks, grouping them by application installation IDs for efficient processing.
+
+- **Webhook Payloads**: Parses and validates webhook payloads, ensuring secure and accurate processing of events.
+- **Queue Payloads**: Deserializes queue messages for processing background jobs, grouping them by application installation ID for efficient handling.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation**: Implements a robust mechanism to validate webhook signatures, ensuring secure and authenticated communications.
-- **Background Job Scheduling**: Uses Azure Timer triggers to schedule periodic background jobs, such as contact synchronization, optimizing resource usage and maintaining system performance.
-- **Error Handling and Logging**: Utilizes Winston for structured logging and error handling, providing detailed insights into application behavior and facilitating debugging.
 
-## Deployment and Development
-- **Deployment**: The app is configured for deployment on Azure Functions, with support for free hosting options via Netlify and Upstash.
-- **Local Development**: Supports local development with Docker for emulating Azure Storage and Ngrok for testing webhooks, alongside a comprehensive setup for VSCode debugging.
+- **Webhook Signature Validation**: Implements a security pattern for validating webhook signatures to ensure authenticity.
+- **Error Handling and Logging**: Consistent error handling with detailed logging using Winston, providing insights into the app's operations and potential issues.
+- **Service Initialization**: Centralized service initialization pattern (`startServices`) to ensure all necessary services are started before processing requests or jobs.
+- **Queue Message Processing**: Efficient processing of queue messages with retry logic and poison queue handling for robust background job execution.
 
-This summary provides an overview of the Me&u Connect app's architecture, integrations, and key functionalities, serving as a reference for AI assistants to understand and interact with the app effectively.
+This summary provides a high-level understanding of the Me&u Connect Seeka app's architecture and implementation, highlighting its integration with Azure services and its focus on mobile ordering and payment tracking in the hospitality sector.

package/dist/ai-context/internal/examples/v1/me-and-u-manage/_ai-summary.md

@@ -1,47 +1,33 @@
+```markdown
 # AI Summary for Seeka App: Me&u Manage
 
-## Overview
+## Purpose and Functionality
+The "Me&u Manage" app is designed to integrate Me&u venues with the Seeka platform, enabling seamless venue management and order tracking. It automatically synchronizes customer data and activities, ensuring CRM systems remain up-to-date without manual intervention. Key features include:
 
-**App Name:** Me&u Manage  
-**Purpose:** The Me&u Manage app integrates Me&u venue management with Seeka for seamless order tracking and CRM synchronization. It automates the syncing of orders and marketing consents from Me&u to Seeka, ensuring that customer data and preferences are up-to-date without manual intervention.
-
-## Key Functionality
-
-- **Order Syncing:** Regularly imports new and updated orders from Me&u to Seeka for CRM workflows and reporting.
-- **Marketing Consent Syncing:** Updates customer marketing preferences in Seeka based on Me&u opt-ins.
-- **Automated Background Processing:** Operates on a schedule (every 15 minutes) and supports initial data backfill during installation.
-- **Simple Setup:** Requires Me&u API access token and venue slug for configuration.
+- **Automatic Order Sync**: Regularly imports new and updated orders from Me&u, making them available for CRM workflows and reporting.
+- **Marketing Consent Sync**: Updates customer preferences based on Me&u marketing opt-ins to maintain compliance and current audience lists.
+- **Simple Installation**: Users can easily install and configure the app by providing a Me&u Access Token and Venue Slug.
 
 ## Key Implementation Patterns
-
-- **Azure Functions:** Utilizes Azure Functions for serverless execution of background jobs and webhooks.
-- **Queue Processing:** Employs Azure Storage Queues to handle order and marketing consent processing asynchronously.
-- **Webhook Handling:** Processes webhooks for installation, updates, and uninstallation events.
-- **Scheduled Jobs:** Uses a timer-triggered function to poll for new data and enqueue processing jobs.
+- **Azure Functions**: The app is built using Azure Functions, leveraging serverless architecture for scalability and efficiency.
+- **Scheduled Jobs**: Utilizes Azure Timer Trigger to poll for new data every 15 minutes, ensuring timely updates.
+- **Queue-Based Processing**: Employs Azure Storage Queues to handle background jobs for processing orders and marketing opt-ins.
+- **Webhook Handling**: Implements webhook endpoints to manage app installation, updates, and uninstallation events.
 
 ## External APIs/Services Integrated
-
-- **Me&u API:** Connects to Me&u's Stable GraphQL API to fetch orders and marketing opt-ins.
-- **Azure Storage:** Uses Azure Storage Queues for managing background job processing.
-- **Ngrok:** Facilitates local development by exposing the app to the internet for testing.
+- **Me&u API**: The app interacts with the Me&u Stable GraphQL API to fetch menus, orders, and marketing opt-ins.
+- **Azure Storage**: Utilizes Azure Storage Queues for managing background job processing.
+- **Ngrok**: Used for exposing local development environments to the internet for testing purposes.
 
 ## Important Data Transformations
-
-- **Order and Consent Grouping:** Orders and marketing consents are grouped by `applicationInstallId` for batch processing.
-- **Payload Deserialization:** Queue payloads are deserialized to extract relevant data for processing.
-- **Error Handling and Retries:** Implements retries and error logging to handle transient errors and prevent data loss.
+- **Order and Marketing Opt-In Processing**: Data from Me&u is ingested and transformed into formats suitable for Seeka's CRM workflows, segments, and automations.
+- **Payload Deserialization**: Queue payloads are deserialized and grouped by application installation ID for efficient processing.
 
 ## Notable Code Patterns
+- **Webhook Signature Validation**: Ensures secure processing of incoming webhooks by validating signatures.
+- **Error Handling and Retries**: Implements robust error handling with retries and poison queue mechanisms to prevent data loss.
+- **Logging**: Uses Winston for structured logging, aiding in monitoring and debugging.
+- **Service Initialization**: Centralized service startup pattern to ensure dependencies are ready before processing requests.
 
-- **Webhook Signature Validation:** Ensures webhook authenticity by validating signatures.
-- **Background Job Triggering:** Uses a combination of Azure Functions and Storage Queues to trigger and manage background jobs efficiently.
-- **Logging and Profiling:** Utilizes Winston for structured logging and profiling of function execution.
-- **Environment Configuration:** Supports local development with Docker and Azurite for emulating Azure services.
-
-## Development and Debugging
-
-- **Local Development:** Supports local development with Docker for Azure services emulation and Ngrok for exposing local endpoints.
-- **VSCode Debugging:** Provides support for debugging with breakpoints in VSCode, primarily tested on Linux.
-- **Environment Setup:** Detailed instructions for setting up the development environment, including Azure Storage Explorer for queue management.
-
-This summary provides a comprehensive understanding of the Me&u Manage app's purpose, implementation, and integration patterns, assisting AI in referencing and utilizing this app effectively.
+This summary provides an overview of the app's architecture, integration points, and key functionalities, offering insights into its design and operational patterns.
+```

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

@@ -1,41 +1,44 @@
 # AI Summary for Seeka App: Now Book It
 
 ## Overview
-The Now Book It app is designed to integrate with restaurant reservation systems to track bookings. It leverages Azure Functions to handle webhooks and background jobs, providing a scalable solution for managing restaurant reservations and related activities.
 
-## Purpose and Functionality
-- **Webhook Handling**: The app processes various webhook events from the Seeka platform, such as app installation, uninstallation, and activity acceptance.
-- **Background Jobs**: Utilizes Azure Storage Queues to manage background job processing, ensuring tasks are executed asynchronously and efficiently.
-- **Scheduled Tasks**: Implements scheduled polling to trigger jobs at regular intervals, facilitating periodic updates and maintenance tasks.
+The **Now Book It** app is designed for integrating with restaurant reservation systems to track bookings. It is built using Azure Functions and provides functionalities for handling webhooks, managing state with Redis, and processing background jobs via Azure Storage Queues. The app is tailored for the hospitality industry, specifically focusing on restaurant reservations and bookings.
 
 ## Key Implementation Patterns
-- **Azure Functions**: The app is structured around serverless functions, enabling event-driven execution with minimal infrastructure management.
-- **Queue-based Job Processing**: Background jobs are triggered via Azure Storage Queues, allowing for decoupled and scalable task execution.
-- **State Management with Redis**: Installation states and other critical data are stored in Redis, providing fast and reliable access to application state.
+
+1. **Azure Functions**: The app uses Azure Functions to handle HTTP requests, process queue messages, and execute scheduled tasks. This serverless architecture allows for scalable and event-driven processing.
+   
+2. **Webhook Handling**: The app processes various webhook events from the Seeka platform, such as app installations, settings updates, and activity acceptance. It validates webhook signatures to ensure secure communication.
+
+3. **State Management**: Redis is used for managing the state of app installations. The app can be configured to use Upstash for Redis hosting, providing a scalable and managed solution.
+
+4. **Background Jobs**: Background tasks are triggered using Azure Storage Queues. The app includes examples of queue processing and scheduled polling to handle periodic tasks.
+
+5. **Logging**: The app uses Winston for logging, with integration to Seq for structured log management and analysis.
 
 ## External APIs/Services Integrated
-- **Azure Functions**: Core platform for executing serverless functions.
-- **Azure Storage Queues**: Used for managing and processing background jobs.
-- **Redis (Upstash)**: Utilized for state management, offering a cloud-based, scalable Redis solution.
-- **Ngrok**: Facilitates local development by exposing local servers to the internet for testing purposes.
+
+- **Azure Functions**: For serverless function execution.
+- **Azure Storage Queues**: For message queueing and background job processing.
+- **Redis (Upstash)**: For state management and caching.
+- **Ngrok**: For exposing local development environments to the internet.
+- **Seeka SDK**: For handling Seeka-specific webhook payloads and operations.
 
 ## Important Data Transformations
-- **Webhook Payload Processing**: Incoming webhook payloads are deserialized and validated before being processed, ensuring data integrity and security.
-- **Queue Payload Deserialization**: Queue messages are deserialized to extract job context, enabling precise control over job execution.
+
+- **Webhook Payloads**: The app deserializes JSON payloads from webhooks and processes them based on their type (e.g., installation, settings update).
+- **Queue Messages**: Queue messages are serialized and deserialized for processing background jobs, ensuring data integrity and consistency.
 
 ## Notable Code Patterns
-- **Webhook Signature Validation**: Ensures the authenticity of incoming webhooks by validating signatures, enhancing security.
-- **Logger Utilization**: Comprehensive logging using Winston and Seq for monitoring and debugging, providing insights into app behavior and performance.
-- **Service Initialization**: Centralized service startup pattern (`startServices`) to ensure all necessary services are initialized before processing requests or jobs.
 
-## Deployment and Development
-- **Azure Deployment**: The app is configured for deployment on Azure Functions, with scripts to automate the build and deployment process.
-- **Local Development**: Supports local development with Docker and Azurite for emulating Azure Storage services, and Ngrok for testing webhooks.
+1. **Webhook Signature Validation**: The app includes a pattern for validating webhook signatures to ensure that incoming requests are authentic.
+
+2. **Background Job Triggering**: The app demonstrates how to trigger background jobs using Azure Storage Queues, which can be reused in other applications requiring asynchronous processing.
+
+3. **State Management with Redis**: The app's approach to managing installation state with Redis can be adapted for other applications needing scalable state management.
+
+4. **Scheduled Task Execution**: The use of Azure Functions' timer triggers for scheduled tasks provides a pattern for executing periodic jobs without manual intervention.
 
-## References
-- [Azure Functions Documentation](https://learn.microsoft.com/en-us/azure/azure-functions/)
-- [Azure Storage Queues Documentation](https://learn.microsoft.com/en-us/azure/storage/queues/)
-- [Upstash Redis](https://upstash.com/)
-- [Ngrok](https://ngrok.com/)
+5. **Logging with Winston and Seq**: The structured logging setup offers a reusable pattern for applications needing robust logging and monitoring capabilities.
 
-This summary provides a comprehensive understanding of the Now Book It app's architecture and implementation, highlighting key patterns and integrations that can be leveraged for similar applications.
+This summary provides an overview of the Now Book It app's architecture and implementation, highlighting its use of Azure services, webhook processing, and state management techniques.

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

@@ -1,41 +1,42 @@
-# AI Summary of Seeka App - SevenRooms Integration
+# AI Summary for Seeka App - SevenRooms
 
 ## Overview
 
-The Seeka app for SevenRooms is designed to integrate with the SevenRooms hospitality CRM to manage restaurant reservations and guest information. It leverages Azure Functions to handle webhooks and background processing tasks, providing a scalable solution for hospitality businesses to automate and streamline their reservation and guest management workflows.
+The Seeka app "sevenrooms" integrates with the SevenRooms hospitality CRM to manage restaurant reservations and guest interactions. It leverages Azure Functions to handle webhooks and manage data processing tasks related to hospitality services.
 
-## Key Features
+## Purpose and Functionality
 
-- **Webhook Handling**: Processes inbound webhooks from SevenRooms and Seeka to update and manage reservations and guest data.
-- **Background Processing**: Utilizes Azure Storage Queues to offload long-running tasks, ensuring efficient handling of webhook data without exceeding Azure Function execution limits.
-- **Logging and Monitoring**: Implements centralized logging using Winston and optional integration with Seq for enhanced log management.
+- **Integration with SevenRooms CRM**: The app processes webhooks from SevenRooms to manage reservations and guest data.
+- **Azure Functions**: Utilizes serverless functions to handle HTTP requests, storage queue messages, and scheduled tasks.
+- **Guest and Reservation Management**: Handles client and reservation data through webhooks and processes them for further actions.
 
-## Implementation Patterns
+## Key Implementation Patterns
 
-- **Azure Functions**: The app is structured around Azure Functions, with HTTP-triggered functions for handling webhooks and a queue-triggered function for processing background tasks.
-- **State Management**: Uses Redis for storing app installation states and other necessary data, allowing for quick retrieval and updates.
-- **Modular Design**: Functions and services are organized into modules, promoting code reuse and maintainability.
+- **Serverless Architecture**: Built on Azure Functions, allowing for scalable and efficient processing of webhook events.
+- **Queue-based Processing**: Uses Azure Storage Queues to offload and process long-running tasks asynchronously.
+- **Centralized Logging**: Implements Winston for logging, with optional integration with Seq for structured logging.
 
-## External APIs and Services
+## External APIs/Services Integrated
 
-- **SevenRooms API**: Integrates with SevenRooms to receive and process reservation and guest management data.
-- **Azure Storage**: Utilizes Azure Storage Queues for managing background jobs and Azure Blob/Table storage for potential data storage needs.
-- **Redis**: Employed for state management, with optional integration with Upstash for cloud-based Redis instances.
+- **SevenRooms API**: For receiving and processing webhooks related to reservations and client data.
+- **Azure Services**: Utilizes Azure Functions, Azure Storage Queues, and optionally Azure Storage Explorer for managing queue items.
+- **Ngrok**: For exposing local development environments to the internet, facilitating webhook testing.
 
-## Data Transformations
+## Important Data Transformations
 
-- **Webhook Payload Processing**: Transforms incoming webhook payloads into structured data that can be processed by the app's business logic.
-- **Queue Message Handling**: Serializes and deserializes messages for queue processing, ensuring data integrity and consistency across background tasks.
+- **Webhook Payload Handling**: Parses and processes JSON payloads from SevenRooms webhooks, extracting necessary data for further processing.
+- **Queue Message Serialization**: Serializes and deserializes messages for Azure Storage Queues to ensure data integrity during asynchronous processing.
 
 ## Notable Code Patterns
 
-- **Centralized Logging**: Uses Winston for logging, with the ability to extend to Seq for advanced log management. This pattern can be reused in other applications requiring robust logging solutions.
-- **Service Initialization**: Implements a `startServices` function to initialize necessary services and dependencies, ensuring that all components are ready before processing requests.
-- **Error Handling and Retry Logic**: Incorporates error handling and retry mechanisms for webhook and queue processing, improving the app's resilience to transient failures.
+- **Child Logger Pattern**: Uses `childLogger` to create context-specific loggers, enhancing log traceability and debugging.
+- **Service Initialization**: Implements `startServices` to initialize necessary services and dependencies before processing requests.
+- **State Management with Redis**: Manages app installation states and configurations using Redis, with flexibility to switch to other state providers.
 
-## Development and Deployment
+## Reusable Code Snippets
 
-- **Local Development**: Supports local development with Docker-based emulation of Azure Storage services and Ngrok for exposing local functions to the internet.
-- **Continuous Deployment**: Includes scripts for building and deploying the app to Azure, facilitating a streamlined deployment process.
+- **Webhook Signature Validation**: Ensures secure processing of webhooks by validating signatures using `throwOnInvalidWebhookSignature`.
+- **Background Job Handling**: Processes background tasks using `triggerBackgroundJob` and `handleSevenRoomsWebhookQueueItem`, which can be adapted for other queue-based processing needs.
+- **Health Check Endpoint**: Implements a simple health check function to monitor the app's availability.
 
-This summary provides an overview of the Seeka app's architecture and implementation, highlighting key patterns and integrations that can be referenced for similar applications in the hospitality and CRM domains.
+This summary provides a high-level understanding of the Seeka app's architecture, integrations, and key functionalities, aiding AI assistants in referencing and utilizing the app's implementation patterns effectively.