@seeka-labs/cli-apps 3.8.2 → 3.8.6

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

@@ -1,26 +1,30 @@
-```markdown
-# AI Summary: Yeastar App
+# AI Summary for Yeastar App
 
 ## Purpose and Functionality
-The Yeastar app is designed to integrate with Yeastar PBX systems to track phone calls and call events. It serves as a bridge between telephony systems and CRM platforms, enabling seamless call tracking and management.
+
+The Yeastar app is designed to integrate with Yeastar PBX systems to track phone calls and call events. It facilitates the synchronization of telephony data with CRM systems, allowing for efficient call tracking and management within business environments.
 
 ## Key Implementation Patterns
-- **Monorepo Structure**: The app is organized using a monorepo structure with Yarn workspaces, separating concerns into `lib`, `server`, and `ui` components.
-- **Azure Functions**: The server-side logic is implemented using Azure Functions, specifically handling HTTP requests for webhook events.
-- **Webhook Handling**: The app processes various webhook events such as app installation, settings updates, and call activities using a centralized handler function.
+
+- **Monorepo Structure**: The app uses a monorepo setup managed by Yarn workspaces, organizing the codebase into separate components (`lib`, `server`, `ui`).
+- **Azure Functions**: The server-side logic is implemented using Azure Functions, providing a scalable and serverless architecture for handling HTTP requests.
+- **Webhook Handling**: The app processes various webhook events from the Seeka platform, such as app installations, settings updates, and call activities.
 
 ## External APIs/Services Integrated
-- **Azure Functions**: Utilized for serverless execution of webhook handlers.
-- **Seeka SDK**: The app integrates with the Seeka SDK to manage webhook payloads and validate webhook signatures.
+
+- **Yeastar PBX**: The app integrates with Yeastar PBX systems to track and manage telephony events.
+- **Seeka Platform**: Utilizes the Seeka SDK for handling webhook payloads and managing app installation states.
+- **Azure Functions**: Deployed on Azure Functions for executing server-side logic in response to HTTP requests.
 
 ## Important Data Transformations
-- **Webhook Payload Parsing**: Incoming HTTP requests are parsed to extract JSON payloads, which are then transformed into specific types defined by the Seeka SDK.
-- **Installation State Management**: The app manages installation states, updating or deleting records based on webhook events.
+
+- **Webhook Payload Parsing**: Incoming webhook requests are parsed and validated to ensure they are from trusted sources, using the `throwOnInvalidWebhookSignature` function.
+- **Installation State Management**: The app maintains the state of app installations, updating or deleting records based on webhook events like `AppInstalled` or `AppUninstalled`.
 
 ## Notable Code Patterns
-- **Logger Integration**: The app uses the `winston` library for logging, providing detailed logs for debugging and monitoring.
-- **Error Handling**: Comprehensive error handling is implemented to manage invalid webhook signatures and unknown installation IDs.
-- **Version Management**: The app includes scripts for automated version bumping and Git tagging, ensuring consistent version control.
 
-This summary provides a high-level overview of the Yeastar app's architecture and implementation, highlighting key patterns and integrations that can be referenced for similar telephony and CRM integration projects.
-```
+- **Logging with Winston**: The app employs the Winston logging library to log detailed information about webhook processing, aiding in debugging and monitoring.
+- **Error Handling**: Comprehensive error handling is implemented to manage exceptions during webhook processing, ensuring robust and reliable operations.
+- **Version Bumping Scripts**: Custom scripts are provided for automating version management and Git operations, ensuring consistent version control practices.
+
+This summary provides an overview of the Yeastar app's architecture and implementation, highlighting its integration with external services and the patterns used to handle telephony data effectively.

package/dist/ai-context/internal/examples/v3/google-ads/_ai-summary.md

@@ -1,31 +1,33 @@
 ```markdown
-# AI Summary for Seeka App: Google Ads
+# AI Summary for Google Ads Seeka App
 
 ## Purpose and Functionality
-The Google Ads app is designed to facilitate conversion tracking and offline conversion imports for Google Ads. It receives activity data from Seeka and pushes conversion data to Google Ads using the Google Ads API. This app is particularly useful for businesses looking to integrate their advertising efforts with Google Ads for enhanced conversion tracking.
+The Google Ads Seeka app is designed to facilitate conversion tracking and offline conversion imports for Google Ads. It receives activity data from Seeka and communicates these conversions to Google Ads using the Google Ads API. This integration helps advertisers track the effectiveness of their campaigns by linking offline activities to online conversions.
 
 ## Key Implementation Patterns
-- **Monorepo Structure**: The app is structured as a monorepo using Yarn workspaces, with separate components for the browser, UI, and server.
-- **Azure Functions**: The app is deployed as an Azure Function, allowing it to handle webhooks and other asynchronous tasks efficiently.
-- **Webhook Handling**: The app processes various webhook events from Seeka, such as app installations, uninstalls, and activity acceptance, to manage conversions and user interactions.
-- **Concurrency Management**: The app uses the `concurrently` package to run multiple processes in parallel, such as server, browser plugin, and UI development.
+- **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, organizing the codebase into distinct components: browser, UI, and server.
+- **Azure Functions**: The server-side logic is deployed as Azure Functions, enabling scalable and event-driven execution.
+- **Webhook Handling**: The app processes various webhook events from Seeka, such as app installation, uninstallation, and activity acceptance, to manage conversion tracking and app state.
+- **Concurrent Processes**: The app utilizes `concurrently` to run multiple processes in parallel, such as server, UI, and browser plugin development.
 
 ## External APIs/Services Integrated
-- **Google Ads API**: The app integrates with the Google Ads API to push conversion data and manage conversion actions.
-- **Azure Storage Queue**: Utilized for managing background jobs and tasks related to conversion tracking.
+- **Google Ads API**: The core functionality of the app revolves around integrating with the Google Ads API to track and import conversions.
+- **Azure Storage Queues**: Used for managing background jobs and processing conversion data asynchronously.
+- **Seeka SDK**: Utilizes Seeka's SDK for handling app installation contexts and webhook payloads.
 
 ## Important Data Transformations
-- **Conversion Mapping**: The app transforms Seeka activity data into Google Ads conversion actions using defined mappings (`SeekaActivityToGoogleConversionActionMapping`).
-- **Webhook Payload Processing**: The app parses and validates webhook payloads to ensure data integrity and proper handling of conversion events.
+- **Activity to Conversion Mapping**: The app defines mappings between Seeka activities and Google Ads conversion actions, enabling precise tracking of specific user activities as conversions.
+- **Webhook Payload Processing**: Incoming webhook payloads are validated and transformed into actionable tasks, such as updating installation states or triggering conversion tracking.
 
 ## Notable Code Patterns
-- **TypeScript Interfaces and Types**: Extensive use of TypeScript interfaces and types for defining data structures, such as `GoogleAdsAppBrowserSdkPluginConfig`, `GoogleAdsConversionSettings`, and `SeekaActivityToGoogleConversionActionMapping`.
-- **Validation Logic**: Although currently a placeholder, the app includes a validation function for installation settings, which is intended to block invalid installation requests.
-- **Logging**: The app employs the `winston` logging library to provide detailed logging for debugging and monitoring purposes.
+- **TypeScript Interfaces and Types**: The app extensively uses TypeScript for defining data models and ensuring type safety across components.
+- **Logging with Winston**: The app employs the Winston library for structured logging, facilitating easier debugging and monitoring.
+- **Environment Configuration**: The app uses environment variables and GitHub secrets for configuration, ensuring secure and flexible deployments.
 
-## Deployment and Configuration
-- **GitHub Actions**: Automated deployment to Azure Functions is managed via GitHub Actions, with specific workflows for different environments (production and staging).
-- **Environment Variables**: The app requires several GitHub secrets and environment variables for configuration, including Azure credentials and Seeka API URLs.
+## Reusable Code Patterns
+- **Webhook Signature Validation**: A reusable pattern for validating webhook signatures to ensure secure communication.
+- **Concurrent Development Scripts**: The use of `concurrently` for parallel process management can be adapted for other projects requiring simultaneous execution of multiple components.
+- **Azure Function Deployment via GitHub Actions**: The deployment workflow using GitHub Actions and Azure Functions can be a template for other serverless applications.
 
-This summary provides an overview of the Google Ads app's architecture, integration points, and key functionalities, which can be referenced for further development or integration efforts.
+This summary provides an overview of the Google Ads Seeka app's architecture and implementation, highlighting key patterns and integrations that could be useful for similar applications.
 ```