@seeka-labs/cli-apps 3.8.5 → 3.8.7

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

@@ -1,27 +1,25 @@
-```markdown
-# AI Summary: Yeastar App
+# AI Summary for Yeastar App
 
 ## Purpose and Functionality
-The Yeastar app is designed to integrate with Yeastar PBX systems for tracking phone calls and call events. It facilitates the management of telephony data and integrates with CRM systems to enhance call tracking capabilities. The app processes various webhook events related to app installation, updates, and call activities.
+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 code 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 incoming webhooks to manage app installations, updates, and call activities. It validates webhook signatures to ensure secure communication.
-- **Logging**: Utilizes the `winston` library for structured logging, aiding in monitoring and debugging.
+- **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.
-- **Azure Functions**: The server component is deployed as an Azure Function, leveraging Microsoft's cloud platform for execution.
+- **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 Processing**: The app parses and processes JSON payloads from webhooks, transforming them into actionable data for installation management and activity tracking.
-- **User Mapping**: Defines interfaces for mapping Yeastar user data, which can be used to associate telephony events with CRM records.
+- **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**: A reusable pattern for validating the authenticity of incoming webhook requests using a secret key.
-- **Service Initialization**: The `startServices` function pattern is used to initialize necessary services before processing webhook events.
-- **Error Handling**: Structured error handling with logging ensures that failures are captured and logged for troubleshooting.
+- **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.
 
-This summary provides an overview of the Yeastar app's architecture and key features, highlighting its integration with telephony systems and use of Azure cloud services.
-```
+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

@@ -2,27 +2,32 @@
 # AI Summary: Google Ads Conversion Tracking App
 
 ## Purpose and Functionality
-The `google-ads` app is designed to facilitate Google Ads conversion tracking and offline conversion import. It receives activity data from Seeka and pushes conversions to Google Ads using the Google Ads API. This app is particularly useful for tracking and managing advertising conversions, both online and offline, within the Google Ads ecosystem.
+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 code into multiple components: browser, UI, and server.
-- **Azure Functions**: The server-side logic is deployed as Azure Functions, allowing for 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 Google Ads conversions.
-- **Concurrent Development**: Utilizes `concurrently` for parallel execution of development tasks, enabling simultaneous 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 app integrates with the Google Ads API to push conversion data and manage Google Ads accounts.
-- **Azure Storage Queue**: Used for queueing and processing conversion tracking jobs asynchronously.
-- **Seeka SDK**: Utilizes Seeka's SDK for handling webhook payloads and managing app installations.
+- **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 transforms Seeka activity data into Google Ads conversion actions using defined mappings (`SeekaActivityToGoogleConversionActionMapping`).
-- **Webhook Payload Processing**: Webhook payloads are parsed and validated to ensure secure and accurate data handling before triggering conversion actions.
+- **Webhook Payload Processing**: Processes and validates incoming webhook payloads to ensure data integrity and security before performing operations.
 
 ## Notable Code Patterns
-- **Validation with Logger**: The `validateInstallationSettings` function uses a logger to provide detailed feedback during the validation of installation settings, ensuring robust error handling.
-- **Asynchronous Job Processing**: Conversion activities are processed asynchronously using Azure Storage Queues, allowing for scalable and efficient handling of large volumes of conversion data.
-- **Environment Configuration via GitHub Actions**: Deployment configurations are managed through GitHub Actions, utilizing environment variables and secrets for secure and flexible deployment to Azure Functions.
+- **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.
 
-This app exemplifies a robust integration of cloud services, asynchronous processing, and API interactions to deliver a comprehensive solution for Google Ads conversion tracking.
-```
+## Reusable Code Patterns
+- **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 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.5";
+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
@@ -48774,7 +48775,7 @@ async function extractZipToDirectory(zipBuffer, destDir) {
 var aiContextCommand = async (options = {}) => {
   const targetDir = options.targetDir || process.cwd();
   const contextDestDir = path5.join(targetDir, ".seeka", "ai", "context");
-  const contextUrl = getContextPackageUrl(options.targetDir, options.contextPackageUrl);
+  const contextUrl = getContextPackageUrl(targetDir, options.contextPackageUrl);
   console.log("Seeka AI Context");
   console.log("================");
   console.log("");
@@ -52549,7 +52550,7 @@ var buildProgram = () => {
       // appSettings: options.appSettings ? map(stringArrayToMap(options.appSettings), (k, v) => { return { name: k } }) : [],
       npmUsername: options.npmUsername,
       npmPassword: options.npmPassword,
-      contextPackageUrl: options.contextPackageUrl
+      contextPackageUrl: getContextPackageUrl(void 0, options.contextPackageUrl)
     };
     await initCommandV2(initOptions);
   }).showHelpAfterError(true);