@seeka-labs/cli-apps 3.8.7 → 3.8.8

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

@@ -1,25 +1,24 @@
 # 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 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.
+The Yeastar app is designed for integration 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 event logging.
 
 ## Key Implementation Patterns
-- **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.
+- **Monorepo Structure**: The app uses a monorepo setup managed with Yarn workspaces, allowing for organized development across multiple 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, particularly webhooks.
+- **Webhook Handling**: The app processes various webhook events from Seeka, including installation, uninstallation, and activity updates, ensuring real-time synchronization with the PBX system.
 
 ## External APIs/Services Integrated
-- **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.
+- **Azure Functions**: Utilized for deploying serverless functions that handle HTTP requests and webhooks.
+- **Seeka SDK**: The app integrates with the Seeka SDK to handle webhook payloads and validate signatures, ensuring secure and reliable communication.
 
 ## Important Data Transformations
-- **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.
+- **Webhook Payload Parsing**: The app parses incoming webhook payloads to extract relevant information and determine the type of event (e.g., installation, activity accepted).
+- **Installation State Management**: It manages the state of app installations, checking for existing installations and updating settings as necessary.
 
 ## 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.
+- **Webhook Signature Validation**: The app includes a robust mechanism for validating webhook signatures using environment variables, enhancing security.
+- **Logging with Winston**: Comprehensive logging is implemented using the Winston library, providing detailed insights into webhook processing and error handling.
+- **Error Handling**: The app employs structured error handling to manage exceptions during webhook processing, ensuring graceful degradation and informative responses.
 
-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.
+This summary provides an overview of the Yeastar app's architecture and implementation, highlighting its integration with external services and key patterns that can be leveraged in similar applications.

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

@@ -1,33 +1,35 @@
 ```markdown
-# AI Summary: Google Ads Conversion Tracking App
+# AI Summary: Seeka Google Ads 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 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.
+The Seeka Google Ads app facilitates conversion tracking and offline conversion imports for Google Ads. It integrates with the Google Ads API to receive activity data from Seeka and push conversion data to Google Ads, enhancing advertising tracking capabilities.
 
 ## Key Implementation Patterns
-- **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.
+- **Azure Functions**: The app is structured to deploy as an Azure Function, handling HTTP requests for webhooks and other interactions.
+- **Monorepo with Yarn Workspaces**: The app uses a monorepo structure managed by Yarn workspaces, organizing components into `lib`, `browser`, `ui`, and `server`.
+- **Concurrent Development**: Utilizes `concurrently` for parallel execution of server, browser, and UI components during development.
+- **Webhook Handling**: Implements webhook handlers to process various Seeka events, such as app installation, uninstallation, and activity acceptance.
 
 ## External APIs/Services Integrated
-- **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.
+- **Google Ads API**: The app interfaces with the Google Ads API to manage conversion tracking and import offline conversions.
+- **Azure Storage Queue**: Utilized for queuing background tasks related to Google Ads activities.
 
 ## 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**: Processes and validates incoming webhook payloads to ensure data integrity and security before performing operations.
+- **Webhook Payload Processing**: Converts incoming webhook payloads into actionable data for Google Ads conversion tracking.
 
 ## Notable Code Patterns
-- **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**: 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.
-```
+- **TypeScript Interfaces and Types**: Extensive use of TypeScript interfaces and types to define data structures, enhancing type safety and code clarity.
+- **Logging with Winston**: Implements structured logging using the Winston library for tracking and debugging webhook events and other operations.
+- **Environment Configuration**: Uses environment variables and GitHub secrets for managing configuration, particularly for Azure deployment and API authentication.
+
+## Deployment and CI/CD
+- **GitHub Actions**: Automated deployment to Azure Functions is configured via GitHub Actions, triggered on pushes to the `main` and `staging` branches.
+- **Environment Management**: Uses GitHub secrets and environment variables to manage deployment settings and credentials securely.
+
+## Reusable Patterns
+- **Webhook Signature Validation**: A pattern for validating webhook signatures to ensure secure communication.
+- **Activity Processing Pipeline**: A modular approach to processing activity data, which can be adapted for other integrations requiring similar data transformations.
+
+This summary provides an overview of the app's architecture, key functionalities, and integration points, aiding AI systems in understanding and referencing the app's implementation.
+```

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.7";
+var version = "3.8.8";
 
 // src/helpers/index.ts
 var fs2 = __toESM(require("fs"), 1);
@@ -52556,9 +52556,10 @@ var buildProgram = () => {
   }).showHelpAfterError(true);
   const aiCmd = program2.command("ai").description(aiCommand.description);
   aiCmd.command("context").description(aiCommand.context.description).option("--target <directory>", aiCommand.context.options.target.description).addOption(new Option("--contextPackageUrl <url>", aiCommand.context.options.contextPackageUrl.description).hideHelp()).action(async (options) => {
-    let packageUrl = getContextPackageUrl(options.target, options.contextPackageUrl);
+    const targetDir = options.target || process.cwd();
+    let packageUrl = getContextPackageUrl(targetDir, options.contextPackageUrl);
     await aiContextCommand({
-      targetDir: options.target,
+      targetDir,
       contextPackageUrl: packageUrl
     });
   }).showHelpAfterError(true);