natureco-sdk 1.0.0

package/README.md

@@ -0,0 +1,292 @@
+# NatureCo JavaScript SDK
+
+Official JavaScript SDK for NatureCo API. Build powerful AI bots and integrate them with Discord, Telegram, Slack, and Instagram.
+
+## Installation
+
+```bash
+npm install natureco-sdk
+```
+
+## Quick Start
+
+```javascript
+const { NatureCoClient } = require('natureco-sdk');
+
+// Initialize client
+const client = new NatureCoClient('nco_your_api_key_here');
+
+// Create a bot
+const bot = await client.bots.create({
+  name: 'My First Bot',
+  systemPrompt: 'You are a helpful assistant',
+  model: 'gpt-4'
+});
+
+console.log('Bot created:', bot);
+```
+
+## Modules
+
+### Bot Management
+
+```javascript
+// List all bots
+const bots = await client.bots.list();
+
+// Get bot details
+const bot = await client.bots.get('bot_id');
+
+// Update bot
+await client.bots.update('bot_id', {
+  name: 'Updated Name',
+  systemPrompt: 'New system prompt'
+});
+
+// Delete bot
+await client.bots.delete('bot_id');
+```
+
+### Channel Integration
+
+```javascript
+// Connect Discord
+await client.channels.connect({
+  botId: 'bot_id',
+  platform: 'discord',
+  token: 'discord_bot_token'
+});
+
+// Connect Telegram
+await client.channels.connect({
+  botId: 'bot_id',
+  platform: 'telegram',
+  token: 'telegram_bot_token'
+});
+
+// List channels
+const channels = await client.channels.list('bot_id');
+
+// Disconnect channel
+await client.channels.disconnect('bot_id', 'channel_id');
+
+// Test channel connection
+await client.channels.test('bot_id', 'channel_id');
+```
+
+### Messaging
+
+```javascript
+// Send message
+await client.messages.send({
+  botId: 'bot_id',
+  message: 'Hello, world!',
+  channel: 'discord',
+  userId: 'user_123'
+});
+
+// Get message history
+const messages = await client.messages.history({
+  botId: 'bot_id',
+  limit: 50,
+  offset: 0
+});
+
+// Get specific message
+const message = await client.messages.get('bot_id', 'message_id');
+```
+
+### Webhooks
+
+```javascript
+// Create webhook
+const webhook = await client.webhooks.create({
+  botId: 'bot_id',
+  url: 'https://your-server.com/webhook',
+  events: ['message.received', 'message.sent'],
+  secret: 'your_webhook_secret'
+});
+
+// List webhooks
+const webhooks = await client.webhooks.list('bot_id');
+
+// Update webhook
+await client.webhooks.update('bot_id', 'webhook_id', {
+  url: 'https://new-url.com/webhook',
+  active: true
+});
+
+// Test webhook
+await client.webhooks.test('bot_id', 'webhook_id');
+
+// Get webhook logs
+const logs = await client.webhooks.logs('bot_id', 'webhook_id', 20);
+
+// Delete webhook
+await client.webhooks.delete('bot_id', 'webhook_id');
+```
+
+### Analytics
+
+```javascript
+// Get analytics overview
+const analytics = await client.analytics.get({
+  botId: 'bot_id',
+  period: 'week' // 'day', 'week', or 'month'
+});
+
+// Get message analytics
+const messageStats = await client.analytics.messages('bot_id', {
+  startDate: '2026-05-01',
+  endDate: '2026-05-09'
+});
+
+// Get channel analytics
+const channelStats = await client.analytics.channels('bot_id');
+
+// Get user analytics
+const userStats = await client.analytics.users('bot_id', { limit: 100 });
+```
+
+### User Management
+
+```javascript
+// Get current user
+const user = await client.user.me();
+
+// Update user profile
+await client.user.update({
+  displayName: 'New Name',
+  bio: 'My bio',
+  avatar: 'https://example.com/avatar.png'
+});
+```
+
+### API Key Management
+
+```javascript
+// List API keys
+const keys = await client.apiKeys.list();
+
+// Create new API key
+const newKey = await client.apiKeys.create({
+  name: 'Production Key',
+  scopes: ['bots:read', 'bots:write']
+});
+
+// Revoke API key
+await client.apiKeys.revoke('key_id');
+```
+
+### Web Widget
+
+```javascript
+// Get embed code
+const embedCode = client.widget.getEmbedCode({
+  botId: 'bot_id',
+  theme: 'light', // 'light' or 'dark'
+  position: 'bottom-right' // 'bottom-right', 'bottom-left', etc.
+});
+
+// Update widget settings
+await client.widget.updateSettings({
+  botId: 'bot_id',
+  theme: 'dark',
+  position: 'bottom-right',
+  welcomeMessage: 'Hello! How can I help you?',
+  primaryColor: '#10B981'
+});
+
+// Get widget settings
+const settings = await client.widget.getSettings('bot_id');
+```
+
+## Error Handling
+
+```javascript
+const { NatureCoClient, NatureCoError } = require('natureco-sdk');
+
+const client = new NatureCoClient('nco_your_api_key');
+
+try {
+  const bot = await client.bots.create({
+    name: 'Test Bot',
+    systemPrompt: 'You are helpful'
+  });
+} catch (error) {
+  if (error instanceof NatureCoError) {
+    console.error('API Error:', error.message);
+    console.error('Status Code:', error.statusCode);
+    console.error('Response:', error.response);
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+## Configuration Options
+
+```javascript
+const client = new NatureCoClient('nco_your_api_key', {
+  baseURL: 'https://api.natureco.me/api/v1', // Custom API base URL
+  timeout: 30000 // Request timeout in milliseconds (default: 30000)
+});
+```
+
+## TypeScript Support
+
+TypeScript definitions are included. Import types:
+
+```typescript
+import { NatureCoClient, NatureCoError } from 'natureco-sdk';
+
+const client = new NatureCoClient('nco_your_api_key');
+
+// TypeScript will provide autocomplete and type checking
+const bot = await client.bots.create({
+  name: 'My Bot',
+  systemPrompt: 'You are helpful',
+  model: 'gpt-4'
+});
+```
+
+## Browser Usage
+
+You can also use the SDK in the browser via CDN:
+
+```html
+<script src="https://cdn.natureco.me/sdk/v1/natureco-sdk.min.js"></script>
+<script>
+  const client = new NatureCoClient('nco_your_api_key');
+  
+  client.bots.list().then(bots => {
+    console.log('Bots:', bots);
+  });
+</script>
+```
+
+## Rate Limiting
+
+The SDK automatically handles rate limiting. When you hit a rate limit, the API will return a `429` status code with a `X-RateLimit-Reset` header indicating when you can retry.
+
+```javascript
+try {
+  await client.bots.create({ name: 'Bot' });
+} catch (error) {
+  if (error.statusCode === 429) {
+    const resetTime = error.response.headers['X-RateLimit-Reset'];
+    console.log('Rate limited. Retry after:', new Date(resetTime * 1000));
+  }
+}
+```
+
+## Support
+
+- Documentation: https://natureco.me/docs
+- SDK Documentation: https://natureco.me/docs/sdk
+- Email: support@natureco.me
+- Developers Portal: https://developers.natureco.me
+
+## License
+
+MIT License - see LICENSE file for details

package/index.js

@@ -0,0 +1,327 @@
+/**
+ * NatureCo JavaScript SDK
+ * @version 1.0.0
+ * @description Official JavaScript SDK for NatureCo API
+ */
+
+class NatureCoClient {
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error('API key is required');
+    }
+
+    this.apiKey = apiKey;
+    this.baseURL = options.baseURL || 'https://api.natureco.me/api/v1';
+    this.timeout = options.timeout || 30000;
+
+    // Initialize modules
+    this.bots = new BotsModule(this);
+    this.channels = new ChannelsModule(this);
+    this.messages = new MessagesModule(this);
+    this.webhooks = new WebhooksModule(this);
+    this.analytics = new AnalyticsModule(this);
+    this.user = new UserModule(this);
+    this.apiKeys = new ApiKeysModule(this);
+    this.widget = new WidgetModule(this);
+  }
+
+  async request(method, endpoint, data = null) {
+    const url = `${this.baseURL}${endpoint}`;
+    const headers = {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    const config = {
+      method,
+      headers,
+    };
+
+    if (data) {
+      config.body = JSON.stringify(data);
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+      const response = await fetch(url, {
+        ...config,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      const responseData = await response.json();
+
+      if (!response.ok) {
+        throw new NatureCoError(
+          responseData.error || 'Request failed',
+          response.status,
+          responseData
+        );
+      }
+
+      return responseData;
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new NatureCoError('Request timeout', 408);
+      }
+      throw error;
+    }
+  }
+}
+
+// Bot Management Module
+class BotsModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async list() {
+    return this.client.request('GET', '/bots');
+  }
+
+  async create({ name, systemPrompt, model = 'gpt-4' }) {
+    return this.client.request('POST', '/bots', {
+      name,
+      system_prompt: systemPrompt,
+      model,
+    });
+  }
+
+  async get(botId) {
+    return this.client.request('GET', `/bots/${botId}`);
+  }
+
+  async update(botId, { name, systemPrompt, model }) {
+    const data = {};
+    if (name) data.name = name;
+    if (systemPrompt) data.system_prompt = systemPrompt;
+    if (model) data.model = model;
+
+    return this.client.request('PATCH', `/bots/${botId}`, data);
+  }
+
+  async delete(botId) {
+    return this.client.request('DELETE', `/bots/${botId}`);
+  }
+}
+
+// Channel Integration Module
+class ChannelsModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async connect({ botId, platform, token, config = {} }) {
+    const validPlatforms = ['discord', 'telegram', 'slack', 'instagram'];
+    if (!validPlatforms.includes(platform)) {
+      throw new Error(`Invalid platform. Must be one of: ${validPlatforms.join(', ')}`);
+    }
+
+    return this.client.request('POST', `/bots/${botId}/channels`, {
+      platform,
+      token,
+      config,
+    });
+  }
+
+  async list(botId) {
+    return this.client.request('GET', `/bots/${botId}/channels`);
+  }
+
+  async disconnect(botId, channelId) {
+    return this.client.request('DELETE', `/bots/${botId}/channels/${channelId}`);
+  }
+
+  async test(botId, channelId) {
+    return this.client.request('POST', `/bots/${botId}/channels/${channelId}/test`);
+  }
+}
+
+// Messaging Module
+class MessagesModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async send({ botId, message, channel, userId }) {
+    return this.client.request('POST', `/bots/${botId}/messages`, {
+      message,
+      channel,
+      user_id: userId,
+    });
+  }
+
+  async history({ botId, limit = 50, offset = 0 }) {
+    return this.client.request('GET', `/bots/${botId}/messages?limit=${limit}&offset=${offset}`);
+  }
+
+  async get(botId, messageId) {
+    return this.client.request('GET', `/bots/${botId}/messages/${messageId}`);
+  }
+}
+
+// Webhook Module
+class WebhooksModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async create({ botId, url, events, secret }) {
+    return this.client.request('POST', `/bots/${botId}/webhooks`, {
+      url,
+      events,
+      secret,
+    });
+  }
+
+  async list(botId) {
+    return this.client.request('GET', `/bots/${botId}/webhooks`);
+  }
+
+  async get(botId, webhookId) {
+    return this.client.request('GET', `/bots/${botId}/webhooks/${webhookId}`);
+  }
+
+  async update(botId, webhookId, { url, events, active }) {
+    const data = {};
+    if (url) data.url = url;
+    if (events) data.events = events;
+    if (typeof active === 'boolean') data.active = active;
+
+    return this.client.request('PATCH', `/bots/${botId}/webhooks/${webhookId}`, data);
+  }
+
+  async delete(botId, webhookId) {
+    return this.client.request('DELETE', `/bots/${botId}/webhooks/${webhookId}`);
+  }
+
+  async test(botId, webhookId) {
+    return this.client.request('POST', `/bots/${botId}/webhooks/${webhookId}/test`);
+  }
+
+  async logs(botId, webhookId, limit = 20) {
+    return this.client.request('GET', `/bots/${botId}/webhooks/${webhookId}/logs?limit=${limit}`);
+  }
+}
+
+// Analytics Module
+class AnalyticsModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async get({ botId, period = 'week' }) {
+    const validPeriods = ['day', 'week', 'month'];
+    if (!validPeriods.includes(period)) {
+      throw new Error(`Invalid period. Must be one of: ${validPeriods.join(', ')}`);
+    }
+
+    return this.client.request('GET', `/bots/${botId}/analytics?period=${period}`);
+  }
+
+  async messages(botId, { startDate, endDate } = {}) {
+    let endpoint = `/bots/${botId}/analytics/messages`;
+    const params = [];
+    if (startDate) params.push(`start_date=${startDate}`);
+    if (endDate) params.push(`end_date=${endDate}`);
+    if (params.length) endpoint += `?${params.join('&')}`;
+
+    return this.client.request('GET', endpoint);
+  }
+
+  async channels(botId) {
+    return this.client.request('GET', `/bots/${botId}/analytics/channels`);
+  }
+
+  async users(botId, { limit = 100 } = {}) {
+    return this.client.request('GET', `/bots/${botId}/analytics/users?limit=${limit}`);
+  }
+}
+
+// User Module
+class UserModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async me() {
+    return this.client.request('GET', '/user/me');
+  }
+
+  async update({ displayName, bio, avatar }) {
+    const data = {};
+    if (displayName) data.display_name = displayName;
+    if (bio) data.bio = bio;
+    if (avatar) data.avatar = avatar;
+
+    return this.client.request('PATCH', '/user/me', data);
+  }
+}
+
+// API Keys Module
+class ApiKeysModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async list() {
+    return this.client.request('GET', '/api-keys');
+  }
+
+  async create({ name, scopes = [] }) {
+    return this.client.request('POST', '/api-keys', {
+      name,
+      scopes,
+    });
+  }
+
+  async revoke(keyId) {
+    return this.client.request('DELETE', `/api-keys/${keyId}`);
+  }
+}
+
+// Widget Module
+class WidgetModule {
+  constructor(client) {
+    this.client = client;
+  }
+
+  getEmbedCode({ botId, theme = 'light', position = 'bottom-right' }) {
+    return `<script src="https://cdn.natureco.me/widget.js" data-bot-id="${botId}" data-theme="${theme}" data-position="${position}"></script>`;
+  }
+
+  async updateSettings({ botId, theme, position, welcomeMessage, primaryColor }) {
+    const data = {};
+    if (theme) data.theme = theme;
+    if (position) data.position = position;
+    if (welcomeMessage) data.welcome_message = welcomeMessage;
+    if (primaryColor) data.primary_color = primaryColor;
+
+    return this.client.request('PATCH', `/bots/${botId}/widget`, data);
+  }
+
+  async getSettings(botId) {
+    return this.client.request('GET', `/bots/${botId}/widget`);
+  }
+}
+
+// Custom Error Class
+class NatureCoError extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = 'NatureCoError';
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+}
+
+// Export for Node.js and browser
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { NatureCoClient, NatureCoError };
+} else if (typeof window !== 'undefined') {
+  window.NatureCoClient = NatureCoClient;
+  window.NatureCoError = NatureCoError;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "natureco-sdk",
+  "version": "1.0.0",
+  "description": "Official JavaScript SDK for NatureCo API",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "natureco",
+    "api",
+    "sdk",
+    "bot",
+    "ai",
+    "chatbot",
+    "discord",
+    "telegram",
+    "slack",
+    "instagram"
+  ],
+  "author": "NatureCo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/natureco/natureco-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/natureco/natureco-sdk/issues"
+  },
+  "homepage": "https://natureco.me/docs/sdk",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}