@seeka-labs/cli-apps 3.8.6 → 3.8.7

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

@@ -1,30 +1,25 @@
 # 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 facilitates the synchronization of telephony data with CRM systems, allowing for efficient call tracking and management within business environments.
+The Yeastar app is designed to integrate with Yeastar PBX systems to track phone calls and call events. It is particularly useful for businesses that need to monitor telephony activities and integrate this data with Customer Relationship Management (CRM) systems. The app processes various webhook events related to app installations and call activities, providing a seamless connection between Yeastar PBX and the Seeka platform.
 
 ## Key Implementation Patterns
-
-- **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.
+- **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, organizing the code into separate components for the library, server, and UI.
+- **Azure Functions**: The server component is built using Azure Functions, enabling serverless execution of webhook handlers.
+- **Webhook Handling**: The app processes different types of webhook events, such as app installation, uninstallation, and activity acceptance, using a centralized handler function.
+- **Logging**: Winston is used for logging, providing detailed logs for webhook processing and error handling.
 
 ## External APIs/Services Integrated
-
-- **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.
+- **Yeastar PBX**: The app integrates with Yeastar PBX systems to track and manage call events.
+- **Seeka SDK**: Utilizes the Seeka SDK for handling webhook payloads and ensuring secure communication through signature validation.
 
 ## Important Data Transformations
-
-- **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`.
+- **Webhook Payload Parsing**: The app parses incoming webhook payloads to extract necessary data for processing different event types.
+- **Installation State Management**: It manages the state of app installations, ensuring that only known installations are processed.
 
 ## Notable Code Patterns
+- **Webhook Signature Validation**: Ensures security by validating webhook signatures using a secret key.
+- **Error Handling**: Implements robust error handling with detailed logging to capture exceptions and provide meaningful error messages.
+- **Version Management**: Uses Yarn scripts for automated version bumping and deployment, ensuring consistent version control across the app.
 
-- **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.
+This summary provides a high-level understanding of the Yeastar app's architecture and implementation, highlighting key patterns and integrations that can be referenced for similar telephony and CRM integration projects.

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

@@ -1,33 +1,33 @@
 ```markdown
-# AI Summary for Google Ads Seeka App
+# AI Summary: Google Ads Conversion Tracking App
 
 ## Purpose and Functionality
-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.
+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 these conversions to Google Ads using the Google Ads API. This app is particularly useful for advertisers looking to track and import offline conversions into their Google Ads accounts.
 
 ## Key Implementation Patterns
-- **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.
+- **Monorepo Structure**: The app is organized into multiple workspaces, each handling different components such as the server, browser, and UI.
+- **Azure Functions**: The app is deployed as an Azure Function, leveraging serverless architecture for handling webhooks and other server-side operations.
+- **Concurrent Development**: Uses `concurrently` to run multiple processes in parallel, such as server, browser plugin, and UI development.
+- **Webhook Handling**: Implements robust webhook handling for various event types like installation, uninstallation, and activity acceptance.
 
 ## External APIs/Services Integrated
-- **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.
+- **Google Ads API**: The core functionality revolves around interacting with the Google Ads API to track and import conversion data.
+- **Azure Functions**: Deployment and execution of server-side logic are managed through Azure Functions, providing scalability and ease of integration with other Azure services.
 
 ## Important Data Transformations
-- **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.
+- **Activity to Conversion Mapping**: The app transforms Seeka activity data into Google Ads conversion actions using defined mappings (`SeekaActivityToGoogleConversionActionMapping`).
+- **Webhook Payload Processing**: Processes and validates incoming webhook payloads to ensure data integrity and security before performing operations.
 
 ## Notable Code Patterns
-- **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.
+- **TypeScript Interfaces and Types**: Extensive use of TypeScript interfaces and types for defining data structures, ensuring type safety and clarity.
+- **Logger Integration**: Utilizes `winston` for logging, providing detailed logs for debugging and monitoring.
+- **Environment Configuration**: Uses environment variables and GitHub secrets for configuration, allowing for secure and flexible deployment setups.
+- **Validation**: Implements a validation function (`validateInstallationSettings`) to ensure installation settings are correct, although it is noted to be a placeholder for future enhancement with Zod.
 
 ## 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.
+- **Webhook Signature Validation**: The pattern for validating webhook signatures can be reused in other applications requiring secure webhook handling.
+- **Concurrent Task Execution**: The use of `concurrently` for running multiple development tasks in parallel is a reusable pattern for improving development efficiency.
+- **Azure Function Deployment**: The deployment setup using GitHub Actions and Azure Functions can be adapted for other serverless applications.
 
-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.
+This summary provides a comprehensive overview of the app's architecture and implementation, highlighting key patterns and integrations that can be leveraged in similar projects.
 ```

package/dist/index.cjs

@@ -39932,7 +39932,7 @@ var os2 = __toESM(require("os"), 1);
 var path6 = __toESM(require("path"), 1);
 
 // package.json
-var version = "3.8.6";
+var version = "3.8.7";
 
 // src/helpers/index.ts
 var fs2 = __toESM(require("fs"), 1);
@@ -48739,13 +48739,14 @@ var getAppInitConfig = (baseDir) => {
 };
 var DEFAULT_PUBLIC_CONTEXT_URL = "https://saseekaaueaprodpub.blob.core.windows.net/sdk-apps/ai-context/public/ai-context-latest.zip";
 var getContextPackageUrl = (baseDir, initialPackageUrl) => {
-  if (!initialPackageUrl) {
-    const initConfig = getAppInitConfig(baseDir);
-    if (initConfig?.contextPackageUrl) {
-      return initConfig.contextPackageUrl;
-    }
+  if (initialPackageUrl) {
+    return initialPackageUrl;
+  }
+  const initConfig = getAppInitConfig(baseDir);
+  if (initConfig?.contextPackageUrl) {
+    return initConfig.contextPackageUrl;
   }
-  return initialPackageUrl || DEFAULT_PUBLIC_CONTEXT_URL;
+  return DEFAULT_PUBLIC_CONTEXT_URL;
 };
 
 // src/commands/ai/context/index.ts