@adobe-commerce/aio-toolkit 1.0.13 → 1.0.15

package/files/cursor-context/rules/aio-toolkit-oop-best-practices.mdc

@@ -0,0 +1,331 @@
+---
+description: Object-Oriented Programming Best Practices for Actions, Lib, and Scripts
+globs: '**/{actions,lib,scripts}/**/*.{ts,js}'
+alwaysApply: true
+---
+
+# Object-Oriented Programming Best Practices
+
+## Overview
+
+This rule enforces essential OOP principles in `actions/`, `lib/`, and `scripts/` directories for maintainable, reusable code.
+
+## Core Principles
+
+### 1. Use Classes for Stateful Components
+
+**When to use classes:**
+- Components with multiple methods and shared state
+- Services that need initialization
+- Reusable utilities with configuration
+- Client builders and singletons
+
+```javascript
+// ✅ Good - Class with state and behavior
+class ProductService {
+  constructor(client, logger) {
+    this.client = client;
+    this.logger = logger;
+  }
+  
+  async getProduct(sku) {
+    this.logger.info(`Fetching product: ${sku}`);
+    return await this.client.get(`products/${sku}`);
+  }
+  
+  async updateProduct(sku, data) {
+    this.logger.info(`Updating product: ${sku}`);
+    return await this.client.put(`products/${sku}`, {}, data);
+  }
+}
+```
+
+### 2. Always Initialize Properties in Constructor
+
+**Initialize all properties that your class will use:**
+
+```javascript
+// ✅ Good - All properties initialized
+class OrderProcessor {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.client = null;
+    this.cache = new Map();
+    this.retryCount = 3;
+  }
+}
+
+// ❌ Bad - Properties not initialized
+class OrderProcessor {
+  constructor(config) {
+    this.config = config;
+    // this.client, this.logger, etc. are undefined!
+  }
+}
+```
+
+### 3. Use Private Fields and Methods
+
+**Keep implementation details private:**
+
+```javascript
+// JavaScript (Node.js 12+)
+class UserManager {
+  #apiKey; // Private field
+  
+  constructor(apiKey) {
+    this.#apiKey = apiKey;
+  }
+  
+  #validateKey() { // Private method
+    return this.#apiKey.length > 0;
+  }
+  
+  async authenticate() {
+    if (!this.#validateKey()) {
+      throw new Error('Invalid API key');
+    }
+    // Use this.#apiKey
+  }
+}
+
+// TypeScript
+class UserManager {
+  private apiKey: string;
+  
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+  
+  private validateKey(): boolean {
+    return this.apiKey.length > 0;
+  }
+}
+```
+
+### 4. Use Dependency Injection
+
+**Inject dependencies instead of hardcoding them:**
+
+```javascript
+// ✅ Good - Dependencies injected
+class OrderService {
+  constructor(paymentProcessor, logger, emailService) {
+    this.paymentProcessor = paymentProcessor;
+    this.logger = logger;
+    this.emailService = emailService;
+  }
+  
+  async processOrder(order) {
+    await this.paymentProcessor.charge(order.total);
+    await this.emailService.send(order.confirmationEmail);
+    this.logger.info('Order processed');
+  }
+}
+
+// ❌ Bad - Dependencies hardcoded
+class OrderService {
+  constructor() {
+    this.paymentProcessor = new PaymentProcessor(); // Hardcoded!
+    this.emailService = new EmailService(); // Hardcoded!
+  }
+}
+```
+
+### 5. Prefer Composition Over Inheritance
+
+**Use composition (has-a) over inheritance (is-a) when possible:**
+
+```javascript
+// ✅ Good - Composition
+class OrderService {
+  constructor(paymentProcessor, inventoryManager) {
+    this.paymentProcessor = paymentProcessor;
+    this.inventoryManager = inventoryManager;
+  }
+  
+  async processOrder(order) {
+    await this.inventoryManager.reserve(order.items);
+    await this.paymentProcessor.charge(order.total);
+  }
+}
+
+// ❌ Bad - Unnecessary inheritance
+class OrderService extends PaymentProcessor {
+  // OrderService is NOT a PaymentProcessor
+}
+```
+
+## Common Patterns
+
+### Singleton Pattern (for expensive resources)
+
+```javascript
+class AdobeCommerceClientBuilder {
+  constructor(baseUrl, consumerKey, consumerSecret, accessToken, accessTokenSecret) {
+    this.baseUrl = baseUrl;
+    this.consumerKey = consumerKey;
+    this.consumerSecret = consumerSecret;
+    this.accessToken = accessToken;
+    this.accessTokenSecret = accessTokenSecret;
+    this.client = null; // Cached instance
+  }
+  
+  getClient() {
+    if (this.client) return this.client; // Return cached
+    
+    const connection = new Oauth1aConnection(
+      this.consumerKey,
+      this.consumerSecret,
+      this.accessToken,
+      this.accessTokenSecret
+    );
+    this.client = new AdobeCommerceClient(this.baseUrl, connection);
+    return this.client;
+  }
+}
+```
+
+### Resolver Pattern (for GraphQL actions)
+
+```javascript
+class GetUserResolver {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  
+  async execute() {
+    return async (args) => {
+      const { logger } = this.ctx;
+      logger.info({ message: 'getUser-execution', args });
+      
+      try {
+        // Business logic here
+        return result;
+      } catch (error) {
+        logger.error({ message: 'getUser-error', error: error.message });
+        throw error;
+      }
+    };
+  }
+}
+```
+
+## Anti-Patterns to Avoid
+
+### ❌ God Classes (doing too much)
+
+```javascript
+// ❌ Bad
+class ApplicationManager {
+  createUser() { }
+  deleteUser() { }
+  createProduct() { }
+  processOrder() { }
+  sendEmail() { }
+  generateReport() { }
+  // ... 50 more methods
+}
+
+// ✅ Good - Separate concerns
+class UserService { }
+class ProductService { }
+class OrderService { }
+class EmailService { }
+```
+
+### ❌ Anemic Models (data only, no behavior)
+
+```javascript
+// ❌ Bad
+class Order {
+  constructor(id, items, total) {
+    this.id = id;
+    this.items = items;
+    this.total = total;
+  }
+}
+// All logic in separate service
+
+// ✅ Good - Rich model with behavior
+class Order {
+  constructor(id, items) {
+    this.id = id;
+    this.items = items;
+    this.total = this.calculateTotal();
+  }
+  
+  calculateTotal() {
+    return this.items.reduce((sum, item) => sum + item.price, 0);
+  }
+  
+  addItem(item) {
+    this.items.push(item);
+    this.total = this.calculateTotal();
+  }
+}
+```
+
+### ❌ Tight Coupling (hardcoded dependencies)
+
+```javascript
+// ❌ Bad
+class OrderService {
+  constructor() {
+    this.emailService = new EmailService(); // Hardcoded!
+  }
+}
+
+// ✅ Good - Loose coupling
+class OrderService {
+  constructor(emailService) {
+    this.emailService = emailService; // Injected
+  }
+}
+```
+
+## Key Takeaways
+
+1. **Use classes for stateful, reusable components**
+2. **Initialize all properties in constructor**
+3. **Use private fields for encapsulation**
+4. **Inject dependencies, don't hardcode them**
+5. **Prefer composition over inheritance**
+6. **Keep classes focused (Single Responsibility)**
+7. **Avoid God classes and anemic models**
+
+## Examples from @adobe-commerce/aio-toolkit
+
+Follow the toolkit's class-based patterns:
+
+```javascript
+// GraphQL Resolver
+class HelloWorld {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  
+  async execute() {
+    return async (args) => {
+      const { logger } = this.ctx;
+      // Implementation
+    };
+  }
+}
+
+// Client Builder with Singleton
+class AdobeCommerceClientBuilder {
+  constructor(baseUrl, credentials) {
+    this.baseUrl = baseUrl;
+    this.credentials = credentials;
+    this.client = null;
+  }
+  
+  getClient() {
+    if (this.client) return this.client;
+    this.client = new AdobeCommerceClient(this.baseUrl, this.credentials);
+    return this.client;
+  }
+}
+```

package/files/cursor-context/rules/aio-toolkit-setup-new-relic-telemetry.mdc

@@ -0,0 +1,354 @@
+---
+description: Setting up New Relic Telemetry for Adobe I/O Runtime Actions
+globs: '**/{app.config.yaml,ext.config.yaml,actions.config.yaml},.env'
+alwaysApply: false
+---
+
+# Setting up New Relic Telemetry
+
+## Trigger Conditions
+
+This rule applies when the user requests to add New Relic telemetry to their actions using any of these phrases:
+
+- "Add New Relic telemetry"
+- "Enable New Relic monitoring"
+- "Setup telemetry for [action-name]"
+- "Configure New Relic for my actions"
+- "Add telemetry to [action-type] action"
+- "Enable observability with New Relic"
+- "Setup New Relic OTLP"
+- "Add telemetry monitoring"
+
+### Supported Action Types
+
+New Relic telemetry can be added to:
+
+- RuntimeAction
+- WebhookAction
+- EventConsumerAction
+- GraphQlAction
+- OpenwhiskAction
+
+**Note**: This rule should be used AFTER an action has been created. It provides recommendations for enabling telemetry on existing actions.
+
+## Overview
+
+The `@adobe-commerce/aio-toolkit` library includes built-in New Relic telemetry support using OpenTelemetry Protocol (OTLP). When enabled, the toolkit automatically:
+
+1. **Instruments actions** with OpenTelemetry
+2. **Exports traces** - Captures action execution spans and timing
+3. **Exports metrics** - Sends performance metrics
+4. **Exports logs** - Forwards structured logs with JSON attribute extraction
+5. **Tags data** - Adds environment, service name, and custom resource attributes
+6. **Detects success/failure** - Automatically detects action outcomes
+
+**No code changes required** - Telemetry is configured entirely through action inputs and environment variables.
+
+## Step 1: Verify Prerequisites and Existing Configuration
+
+Before proceeding, verify and analyze the current configuration:
+
+1. **Action exists** - Check that the action is already created
+2. **Toolkit is installed** - Confirm `@adobe-commerce/aio-toolkit` is in `package.json`
+3. **Check existing telemetry configuration**:
+   - Check if `.env` file exists in project root directory (workspace root)
+   - If project root `.env` exists, check for these variables:
+     - `ENVIRONMENT` - Note the value if present (dev, staging, production)
+     - `NEW_RELIC_SERVICE_NAME` - Note the value if present
+     - `NEW_RELIC_LICENSE_KEY` - Note if present (don't show the value)
+     - `NEW_RELIC_URL` - Note if custom endpoint is configured
+   - Check existing actions in `app.config.yaml` for telemetry inputs to detect default environment
+     - Look for `ENVIRONMENT` input in any action
+     - Common values: `dev`, `staging`, `production`
+4. Only proceed to Step 2 after analyzing the current configuration
+
+## Step 2: Ask Required Questions
+
+Before configuring telemetry, ask the user the following questions:
+
+**Important**:
+
+- **Smart Configuration Detection**: Based on Step 1 analysis, skip questions for values already configured in project root `.env` or detected from existing actions
+- If `ENVIRONMENT` exists in project root `.env`: Skip Question 2, use existing value
+- If `NEW_RELIC_SERVICE_NAME` exists in project root `.env`: Skip Question 3, use existing value
+- If `NEW_RELIC_LICENSE_KEY` exists in project root `.env`: Skip Question 4, confirm it's already set
+- If any question is unclear or you need more information to proceed, continue asking follow-up questions until you have complete clarity. Do not make assumptions - keep the conversation going until all details are clear.
+- Once all questions are clearly answered, move to Step 3 to get user confirmation before making any configuration changes.
+
+1. **Which actions need telemetry?**
+   - Provide comma-separated action names
+   - Example: `runtime-action, webhook-action, product-consumer`
+   - Or say "all actions" to add telemetry to every action in the project
+2. **Environment name** (for filtering and tagging in New Relic)?
+   - **ONLY ask if `ENVIRONMENT` is NOT in project root `.env`** (from Step 1)
+   - **If already configured**: Skip this question and use the existing value
+   - Options: `dev`, `staging`, `production`, `test`, or custom name
+   - **If detected from existing actions in Step 1**: Show detected value and ask to confirm or change
+     - Example: "I detected `staging` from your existing actions. Use this environment or specify a different one?"
+   - **If not detected**: Ask what environment to use (no default assumption)
+   - Note: This appears as a tag in New Relic for filtering data
+
+3. **Service name** (for New Relic identification)?
+   - **ONLY ask if `NEW_RELIC_SERVICE_NAME` is NOT in project root `.env`** (from Step 1)
+   - **If already configured**: Skip this question and use the existing value
+   - Provide a descriptive name for your service
+   - Example: `my-commerce-app`, `customer-portal`, `order-processing`
+   - Note: This appears as the service name in New Relic dashboards
+
+4. **Do you have a New Relic license key?**
+   - **ONLY ask if `NEW_RELIC_LICENSE_KEY` is NOT in project root `.env`** (from Step 1)
+   - **If already configured**: Skip this question and confirm the key is set
+   - Options: Yes or No
+
+   **If No, provide instructions**:
+   - Log in to [New Relic](https://one.newrelic.com/)
+   - Navigate to **Account settings** > **API keys**
+   - Find or create an **Ingest - License** key type
+   - Copy the key value (it starts with `NRAK-`)
+   - You'll add this to your project root `.env` file
+
+## Step 3: Confirm Telemetry Configuration
+
+After receiving answers to ALL questions, present a comprehensive summary and **wait for user confirmation** before proceeding to Step 4:
+
+---
+
+### 📊 New Relic Telemetry Configuration Summary
+
+**Actions to Configure:**
+
+- [List of action names]
+
+**Existing Configuration** (detected from project root `.env` and actions):
+[If any values were detected in Step 1, list them here:]
+
+- ✅ **Environment:** `[existing-environment]` (already configured in project root `.env`)
+- ✅ **Service Name:** `[existing-service-name]` (already configured in project root `.env`)
+- ✅ **License Key:** Configured in project root `.env` (starts with `NRAK-...`)
+  [Only if NEW_RELIC_URL was detected:]
+- ✅ **Custom Endpoint:** `[existing-endpoint]` (already configured in project root `.env`)
+
+**New Configuration** (to be added):
+[Only show values that are NEW or changed:]
+
+- **Environment:** [environment name] [Only if NEW - not in project root .env]
+- **Service Name:** [service name] [Only if NEW - not in project root .env]
+- **License Key:** [To be added] [Only if NEW - not in project root .env]
+- **OTLP Endpoint:** Default US endpoint (https://otlp.nr-data.net) [Only if no custom endpoint detected]
+
+**What Will Be Added:**
+
+For each action, the following inputs will be added to the action configuration:
+
+```yaml
+inputs:
+  LOG_LEVEL: debug
+  ENVIRONMENT: $ENVIRONMENT
+  ENABLE_TELEMETRY: true
+  NEW_RELIC_TELEMETRY: true
+  NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+  NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+  [NEW_RELIC_URL: $NEW_RELIC_URL]  # Only if custom endpoint was detected in project root .env
+```
+
+**Environment Variables** (project root `.env` file):
+
+[If all variables already exist:]
+✅ All required environment variables are already configured in project root `.env`
+
+[If some need to be added:]
+You'll need to add these to your project root `.env` file:
+
+```bash
+[Only show variables that DON'T already exist:]
+ENVIRONMENT=[environment]  # NEW (e.g., staging, production)
+NEW_RELIC_SERVICE_NAME=[service-name]  # NEW
+NEW_RELIC_LICENSE_KEY=[your-license-key]  # NEW
+NEW_RELIC_URL=[custom-endpoint]  # NEW (optional)
+```
+
+**Files to Modify:**
+
+- ✏️ `app.config.yaml` or `[extension-path]/ext.config.yaml` (for each action)
+  [Only if new variables:]
+- 📄/✏️ `.env` (project root) - Create or update with new environment variables
+
+---
+
+**Should I proceed with adding New Relic telemetry to these actions?**
+
+## Step 4: Add Telemetry Configuration
+
+Once confirmed, update the action configurations and provide environment variable setup instructions.
+
+### A. Update Action Configurations
+
+For each action identified, add telemetry inputs to the action configuration.
+
+#### Standard Actions (in `app.config.yaml`)
+
+Locate the action under `application.runtimeManifest.packages.[package-name].actions.[action-name]` and add/update the `inputs` section:
+
+```yaml
+[action-name]:
+  function: actions/[action-name]/index.[js/ts]
+  web: 'yes' # or 'no' for event consumers
+  runtime: nodejs:22
+  inputs:
+    LOG_LEVEL: debug
+    ENVIRONMENT: $ENVIRONMENT
+    ENABLE_TELEMETRY: true
+    NEW_RELIC_TELEMETRY: true
+    NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+    NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+    # Only add if custom endpoint specified:
+    # NEW_RELIC_URL: $NEW_RELIC_URL
+  annotations:
+    require-adobe-auth: [true/false]
+    final: true
+```
+
+#### Packaged Actions (in `actions/[package]/actions.config.yaml`)
+
+For actions defined in separate config files:
+
+```yaml
+[action-name]:
+  function: [action-name]/index.[js/ts]
+  web: 'yes'  # or 'no' for event consumers
+  runtime: nodejs:22
+  inputs:
+    LOG_LEVEL: debug
+    ENVIRONMENT: $ENVIRONMENT
+    ENABLE_TELEMETRY: true
+    NEW_RELIC_TELEMETRY: true
+    NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+    NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+    # Only add if custom endpoint specified:
+    # NEW_RELIC_URL: $NEW_RELIC_URL
+  annotations:
+    require-adobe-auth: [true/false]
+    final: true
+```
+
+#### Extension Point Actions (in `[extension-path]/ext.config.yaml`)
+
+For actions in extension points, follow the same pattern but update the extension's config file:
+
+```yaml
+runtimeManifest:
+  packages:
+    [package-name]:
+      license: Apache-2.0
+      actions:
+        [action-name]:
+          function: actions/[action-name]/index.js
+          web: 'yes'
+          runtime: nodejs:22
+          inputs:
+            LOG_LEVEL: debug
+            ENVIRONMENT: $ENVIRONMENT
+            ENABLE_TELEMETRY: true
+            NEW_RELIC_TELEMETRY: true
+            NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+            NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+            # Only add if custom endpoint specified:
+            # NEW_RELIC_URL: $NEW_RELIC_URL
+          annotations:
+            require-adobe-auth: [true/false]
+            final: true
+```
+
+### B. Environment Variables Setup
+
+**If all variables exist**: ✅ `ENVIRONMENT`, `NEW_RELIC_SERVICE_NAME`, `NEW_RELIC_LICENSE_KEY` (and optional `NEW_RELIC_URL`) already in project root `.env` - no changes needed.
+
+**If variables need adding**:
+
+1. Check/create project root `.env` file (workspace root)
+2. Add missing variables (only show variables that need to be added)
+3. Get license key from New Relic → Account settings → API keys → Ingest - License (starts with `NRAK-`)
+4. Never commit `.env` - ensure it's in `.gitignore`
+
+```bash
+# Add to project root .env
+ENVIRONMENT=[environment]
+NEW_RELIC_SERVICE_NAME=[service-name]
+NEW_RELIC_LICENSE_KEY=[license-key]
+NEW_RELIC_URL=[custom-endpoint]  # Optional: EU only
+```
+
+## Step 5: Testing and Verification
+
+**Deploy**: Run `aio app deploy`
+
+**Test**: Invoke action via `aio runtime action invoke [action-name] --result` or API/webhook call
+
+**Verify in New Relic** (1-2 minutes delay): Login → APM & Services → Find service → View Traces/Logs/Metrics
+
+**Troubleshooting**: Check `NEW_RELIC_LICENSE_KEY` and `NEW_RELIC_SERVICE_NAME` in project root `.env`, run `aio app logs` for errors, verify `ENABLE_TELEMETRY: true` in action inputs, confirm correct New Relic account/region.
+
+**Common Errors**: Missing license key/service name in project root `.env`, invalid configuration, wrong data center (EU requires `NEW_RELIC_URL`).
+
+## Additional Recommendations
+
+**Dashboards & Monitoring**: Create custom dashboards for success/failure rates, execution duration, request volume, and error trends.
+
+**Alerting**: Set up alerts for high error rates, slow execution, failed invocations, or missing telemetry data.
+
+**Multiple Environments**: Use different `ENVIRONMENT` values (dev/staging/prod) in separate `.env.{env}` files in project root. Filter New Relic data by environment tag.
+
+**CI/CD Integration**: Store `NEW_RELIC_LICENSE_KEY` in CI/CD secrets (GitHub Actions, etc.), set environment-specific values in deployment workflows.
+
+**Custom OTLP Endpoint**: For EU data center, add `NEW_RELIC_URL=https://otlp.eu01.nr-data.net` to project root `.env` and reference as `NEW_RELIC_URL: $NEW_RELIC_URL` in action inputs. US uses default `https://otlp.nr-data.net`.
+
+**Cost & Performance**: Telemetry adds ~1-5ms latency (asynchronous, non-blocking). Monitor data ingest volume, consider sampling for high-volume actions, review billing regularly.
+
+## Key Features
+
+**Automatic Instrumentation**: Captures traces (execution spans, timing, success/failure, HTTP codes), structured logs (`logger.info/error/warn`, JSON attributes, trace correlation), metrics (duration, invocation counts, error rates), and resource attributes (`service.name`, `environment`, `service.version`).
+
+**Multi-Provider Support**: Priority order: New Relic → Grafana → None. Explicit configuration validation ensures failures when required config is missing (e.g., `NEW_RELIC_LICENSE_KEY`) rather than silent fallback.
+
+## Important Notes
+
+1. **No Code Changes**: Telemetry configured via action inputs only
+2. **Auto-Export**: Toolkit handles OpenTelemetry setup, export, error handling
+3. **Security**: Never commit license keys - use project root `.env` + `.gitignore`
+4. **Environment Tags**: Set `ENVIRONMENT` in project root `.env` to filter by environment
+5. **Service Names**: Use descriptive names for identification; same name for related actions or different names for separate services
+6. **Data Center**: US (default), EU requires `NEW_RELIC_URL` in project root `.env`
+7. **Providers**: Supports New Relic, Grafana; this rule focuses on New Relic
+
+## Example Configuration
+
+**Action inputs (app.config.yaml or ext.config.yaml)**:
+
+```yaml
+[action-name]:
+  inputs:
+    LOG_LEVEL: debug
+    ENVIRONMENT: $ENVIRONMENT
+    ENABLE_TELEMETRY: true
+    NEW_RELIC_TELEMETRY: true
+    NEW_RELIC_SERVICE_NAME: $NEW_RELIC_SERVICE_NAME
+    NEW_RELIC_LICENSE_KEY: $NEW_RELIC_LICENSE_KEY
+    NEW_RELIC_URL: $NEW_RELIC_URL # Optional: for EU data center
+```
+
+**Project root .env**:
+
+```bash
+ENVIRONMENT=production  # or dev, staging
+NEW_RELIC_SERVICE_NAME=my-commerce-app
+NEW_RELIC_LICENSE_KEY=NRAK-XXXXXXXXXXXXXXXXXXXXX
+NEW_RELIC_URL=https://otlp.eu01.nr-data.net  # Optional: EU only
+```
+
+## Reference Links
+
+- [New Relic Account Setup](https://one.newrelic.com/)
+- [New Relic API Keys](https://one.newrelic.com/api-keys)
+- [New Relic OTLP Endpoint](https://docs.newrelic.com/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/opentelemetry-setup/)
+- [OpenTelemetry Documentation](https://opentelemetry.io/docs/)
+- [@adobe-commerce/aio-toolkit NPM](https://www.npmjs.com/package/@adobe-commerce/aio-toolkit)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe-commerce/aio-toolkit",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "A comprehensive TypeScript toolkit for Adobe App Builder applications providing standardized Adobe Commerce integrations, I/O Events orchestration, file storage utilities, authentication helpers, and robust backend development tools with 100% test coverage.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -14,10 +14,14 @@
   },
   "files": [
     "dist/**/*",
+    "files/**/*",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
+  "bin": {
+    "aio-toolkit-cursor-context": "dist/aio-toolkit-cursor-context/bin/cli.js"
+  },
   "scripts": {
     "build": "tsup",
     "build:watch": "tsup --watch",
@@ -93,6 +97,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
+    "@adobe-commerce/commerce-extensibility-tools": "^1.6.0",
     "typescript": ">=4.9.0"
   },
   "engines": {