sentilyze 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sentilyze.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,305 @@
+# Sentilyze SDK
+
+Official Node.js SDK for [Sentilyze.ai](https://sentilyze.ai) - Transform customer feedback into actionable insights with AI-powered sentiment analysis.
+
+[![npm version](https://img.shields.io/npm/v/sentilyze.svg)](https://www.npmjs.com/package/sentilyze)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+npm install sentilyze
+```
+
+## Quick Start
+
+```javascript
+const SentilyzeClient = require('sentilyze');
+
+// Initialize the client with your API key
+const client = new SentilyzeClient({
+  apiKey: 'senti_your_api_key_here'
+});
+
+// Analyze sentiment
+const result = await client.analyze('This product is amazing!');
+console.log(result);
+```
+
+**Response:**
+```javascript
+{
+  sentiment: 'positive',
+  score: 5.2,
+  summary: 'Customer expresses high satisfaction with the product',
+  tags: ['product', 'satisfaction', 'quality'],
+  usage: {
+    requestsUsed: 1,
+    requestsLimit: 1000,
+    requestsRemaining: 999,
+    subscriptionPlan: 'Starter',
+    resetDate: '2025-12-31T23:59:59.999Z'
+  }
+}
+```
+
+## Features
+
+- ✅ **Sentiment Analysis** - Detect positive, negative, or neutral sentiment
+- ✅ **Happiness Scoring** - Measure happiness levels from 1-6 scale
+- ✅ **AI-Powered Summary** - Get concise summaries of feedback
+- ✅ **Tag Extraction** - Automatic keyword and topic extraction
+- ✅ **Batch Processing** - Analyze multiple texts efficiently
+- ✅ **Usage Tracking** - Monitor your API usage in real-time
+- ✅ **Error Handling** - Comprehensive error messages and retry logic
+
+## API Reference
+
+### Initialize Client
+
+```javascript
+const client = new SentilyzeClient({
+  apiKey: 'senti_your_api_key',        // Required: Your API key
+  baseUrl: 'https://api.sentilyze.ai', // Optional: Custom API URL
+  timeout: 30000                        // Optional: Request timeout (ms)
+});
+```
+
+### Analyze Text
+
+Analyze a single text for sentiment and happiness:
+
+```javascript
+// Simple string
+const result = await client.analyze('Customer feedback text');
+
+// With options object
+const result = await client.analyze({
+  feedback: 'Customer feedback text'
+});
+```
+
+**Response Structure:**
+```javascript
+{
+  sentiment: 'positive' | 'negative' | 'neutral',
+  score: number,              // 1-6 scale (decimal)
+  summary: string,            // AI-generated summary
+  tags: string[],             // Extracted keywords
+  usage: {
+    requestsUsed: number,
+    requestsLimit: number | 'unlimited',
+    requestsRemaining: number | 'unlimited',
+    subscriptionPlan: string,
+    resetDate: string
+  }
+}
+```
+
+**Example:**
+```javascript
+const result = await client.analyze('The product quality is excellent, but shipping was slow');
+
+console.log(result.sentiment);  // 'positive'
+console.log(result.score);      // 4.5
+console.log(result.summary);    // 'Mixed feedback with product praise and shipping concerns'
+console.log(result.tags);       // ['product', 'quality', 'shipping', 'delivery']
+```
+
+### Batch Analysis
+
+Analyze multiple texts efficiently with concurrency control:
+
+```javascript
+const texts = [
+  'Great service!',
+  'Not satisfied',
+  'Could be better',
+  'Excellent product!'
+];
+
+const result = await client.batchAnalyze(texts, {
+  concurrency: 5  // Optional: Number of parallel requests (default: 5)
+});
+
+console.log(result);
+```
+
+**Response Structure:**
+```javascript
+{
+  results: [        // Array of successful analysis results
+    {
+      sentiment: 'positive',
+      score: 5.8,
+      summary: '...',
+      tags: [...],
+      usage: {...}
+    },
+    // ... more results
+  ],
+  errors: [],               // Array of failed analyses with error details
+  totalProcessed: 4,        // Total texts processed
+  successCount: 4,          // Number of successful analyses
+  errorCount: 0             // Number of failed analyses
+}
+```
+
+**Example:**
+```javascript
+const texts = ['Happy customer!', 'Very disappointed', 'It works fine'];
+const result = await client.batchAnalyze(texts);
+
+console.log(`Successfully analyzed ${result.successCount}/${result.totalProcessed} texts`);
+
+// Calculate average score
+const avgScore = result.results.reduce((sum, r) => sum + r.score, 0) / result.results.length;
+console.log(`Average score: ${avgScore.toFixed(1)}/6`);
+```
+
+### Get Usage Statistics
+
+Check your current API usage:
+
+```javascript
+const usage = await client.getUsage();
+console.log(usage);
+```
+
+**Response:**
+```javascript
+{
+  data: {
+    requestsUsed: 150,
+    requestsLimit: 1000,
+    requestsRemaining: 850,
+    subscriptionPlan: 'Starter',
+    resetDate: '2025-12-31T23:59:59.999Z',
+    currentPeriod: {
+      month: 12,
+      year: 2025
+    }
+  }
+}
+```
+
+## Error Handling
+
+The SDK provides detailed error handling:
+
+```javascript
+try {
+  const result = await client.analyze('Text to analyze');
+} catch (error) {
+  if (error.status === 401) {
+    console.error('Invalid API key');
+  } else if (error.status === 429) {
+    console.error('Rate limit exceeded');
+  } else if (error.message.includes('timeout')) {
+    console.error('Request timed out');
+  } else if (error.message.includes('Network error')) {
+    console.error('Cannot reach API');
+  } else {
+    console.error('Analysis failed:', error.message);
+  }
+}
+```
+
+## Common Use Cases
+
+### Customer Feedback Analysis
+```javascript
+// Analyze customer review
+const review = await client.analyze(
+  'The product quality is excellent, but shipping was slow'
+);
+
+if (review.sentiment === 'positive') {
+  console.log(`Happy customer! Score: ${review.score}/6`);
+  console.log(`Summary: ${review.summary}`);
+  console.log(`Topics: ${review.tags.join(', ')}`);
+}
+```
+
+### Bulk Survey Processing
+```javascript
+// Process survey responses
+const responses = [
+  'Great experience overall',
+  'Service needs improvement',
+  'Product exceeded expectations'
+];
+
+const result = await client.batchAnalyze(responses);
+console.log(`Analyzed ${result.successCount} responses`);
+
+// Calculate average happiness
+const avgScore = result.results.reduce(
+  (sum, r) => sum + r.score, 0
+) / result.results.length;
+
+console.log(`Average satisfaction: ${avgScore.toFixed(1)}/6`);
+
+// Count sentiments
+const sentiments = result.results.reduce((acc, r) => {
+  acc[r.sentiment] = (acc[r.sentiment] || 0) + 1;
+  return acc;
+}, {});
+
+console.log('Sentiment distribution:', sentiments);
+// { positive: 2, negative: 1 }
+```
+
+### Real-time Feedback Monitoring
+```javascript
+// Monitor new feedback in real-time
+async function processNewFeedback(feedbackText) {
+  const result = await client.analyze(feedbackText);
+  
+  // Alert on negative feedback
+  if (result.sentiment === 'negative' && result.score < 3) {
+    console.warn('⚠️ Negative feedback detected!');
+    console.warn(`Score: ${result.score}/6`);
+    console.warn(`Summary: ${result.summary}`);
+    // Trigger notification to support team
+  }
+  
+  return result;
+}
+```
+
+## Subscription Plans
+
+| Plan | Requests/Month | Price | Best For |
+|------|----------------|-------|----------|
+| Developer | 100 | Free | Testing & development |
+| Starter | 1,000 | $29 | Small projects |
+| Professional | 10,000 | $199 | Growing businesses |
+| Enterprise | Unlimited | Custom | Large organizations |
+
+Get your API key at [sentilyze.ai](https://sentilyze.ai)
+
+## Response Field Descriptions
+
+- **sentiment**: Classification of the feedback (`positive`, `negative`, or `neutral`)
+- **score**: Happiness/satisfaction score on a 1-6 scale (decimal values like 4.5 are supported)
+  - 1-2: Very unhappy
+  - 3-4: Neutral to slightly satisfied
+  - 5-6: Very happy
+- **summary**: AI-generated concise summary of the feedback
+- **tags**: Array of extracted keywords and topics from the text
+- **usage**: Current API usage information for rate limiting and billing
+
+## Support
+
+- 📧 Email: support@sentilyze.ai
+- 🌐 Website: https://www.sentilyze.ai
+- 📚 Dashboard: https://www.sentilyze.ai/dashboard
+
+## License
+
+MIT © Sentilyze.ai
+
+---
+
+Made with ❤️ by [Sentilyze.ai](https://sentilyze.ai)

package/index.js

@@ -0,0 +1,174 @@
+/**
+ * Sentilyze SDK - Official Node.js client for Sentilyze.ai
+ * Analyze sentiment and happiness levels from customer feedback
+ * @version 2.0.0
+ */
+
+class SentilyzeClient {
+  /**
+   * Create a Sentilyze client instance
+   * @param {Object} config - Configuration options
+   * @param {string} config.apiKey - Your Sentilyze API key
+   * @param {string} [config.baseUrl='https://api.sentilyze.ai'] - API base URL
+   * @param {number} [config.timeout=30000] - Request timeout in milliseconds
+   */
+  constructor(config) {
+    if (!config || !config.apiKey) {
+      throw new Error('API key is required. Get yours at https://sentilyze.ai');
+    }
+
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || 'https://api.sentilyze.ai';
+    this.timeout = config.timeout || 30000;
+  }
+
+  /**
+   * Internal method to make API requests
+   * @private
+   */
+  async _request(endpoint, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        ...options,
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json().catch(() => null);
+
+      if (!response.ok) {
+        const errorMessage = data?.error?.message || data?.message || response.statusText;
+        const error = new Error(errorMessage);
+        error.status = response.status;
+        error.response = data;
+        throw error;
+      }
+
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      
+      if (error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      
+      if (error.message.includes('fetch') && !error.status) {
+        throw new Error('Network error: Unable to reach Sentilyze API');
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Analyze sentiment and happiness from text
+   * @param {string|Object} input - Text to analyze or options object
+   * @param {string} input.feedback - Text to analyze (when using options object)
+   * @returns {Promise<Object>} Analysis results with sentiment, score, summary, tags, and usage info
+   * 
+   * @example
+   * const result = await client.analyze('This product is amazing!');
+   * console.log(result.sentiment); // 'positive'
+   * console.log(result.score); // 5.2
+   * console.log(result.summary); // 'Customer expresses high satisfaction'
+   * console.log(result.tags); // ['product', 'satisfaction']
+   * console.log(result.usage); // { requestsUsed: 1, requestsLimit: 1000, ... }
+   */
+  async analyze(input) {
+    const feedback = typeof input === 'string' ? input : input.feedback;
+
+    if (!feedback || typeof feedback !== 'string') {
+      throw new Error('Text is required for analysis');
+    }
+
+    if (feedback.trim().length === 0) {
+      throw new Error('Text cannot be empty');
+    }
+
+    return await this._request('/api/analyze', {
+      method: 'POST',
+      body: JSON.stringify({ feedback })
+    });
+  }
+
+  /**
+   * Batch analyze multiple texts (processes them in parallel)
+   * @param {string[]} texts - Array of texts to analyze
+   * @param {Object} [options] - Batch options
+   * @param {number} [options.concurrency=5] - Number of concurrent requests
+   * @returns {Promise<Object>} Object containing results array and statistics
+   * 
+   * @example
+   * const result = await client.batchAnalyze([
+   *   'Great service!',
+   *   'Not satisfied with the product',
+   *   'Average experience'
+   * ]);
+   * console.log(result.successCount); // 3
+   * console.log(result.results[0].sentiment); // 'positive'
+   */
+  async batchAnalyze(texts, options = {}) {
+    if (!Array.isArray(texts) || texts.length === 0) {
+      throw new Error('An array of texts is required for batch analysis');
+    }
+
+    const concurrency = options.concurrency || 5;
+    const results = [];
+    const errors = [];
+
+    // Process in batches to respect concurrency
+    for (let i = 0; i < texts.length; i += concurrency) {
+      const batch = texts.slice(i, i + concurrency);
+      const batchResults = await Promise.allSettled(
+        batch.map((text, index) => 
+          this.analyze(text).catch(error => {
+            errors.push({ index: i + index, text, error: error.message });
+            return null;
+          })
+        )
+      );
+      
+      results.push(...batchResults.map(r => r.status === 'fulfilled' ? r.value : null));
+    }
+
+    return {
+      results: results.filter(r => r !== null),
+      errors,
+      totalProcessed: texts.length,
+      successCount: results.filter(r => r !== null).length,
+      errorCount: errors.length
+    };
+  }
+
+  /**
+   * Get API usage statistics for your account
+   * @returns {Promise<Object>} Usage statistics for current period
+   * 
+   * @example
+   * const usage = await client.getUsage();
+   * console.log(usage.data);
+   * // {
+   * //   requestsUsed: 150,
+   * //   requestsLimit: 1000,
+   * //   requestsRemaining: 850,
+   * //   subscriptionPlan: 'Starter',
+   * //   resetDate: '2025-12-31T23:59:59.999Z'
+   * // }
+   */
+  async getUsage() {
+    return await this._request('/api/usage', {
+      method: 'GET'
+    });
+  }
+}
+
+module.exports = SentilyzeClient;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "sentilyze",
+  "version": "2.0.0",
+  "description": "Official Node.js SDK for Sentilyze.ai - Analyze sentiment and happiness levels from customer feedback with AI",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "sentilyze",
+    "sentiment",
+    "analysis",
+    "sentiment-analysis",
+    "happiness",
+    "ai",
+    "nlp",
+    "customer-feedback",
+    "gpt-4",
+    "text-analysis",
+    "analytics",
+    "insights",
+    "word-cloud",
+    "customer-satisfaction"
+  ],
+  "author": "Sentilyze.ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/sentilyze-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/sentilyze-sdk/issues"
+  },
+  "homepage": "https://sentilyze.ai",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}