safetygates 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CycleCore Technologies LLC
+
+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,200 @@
+# SafetyGates SDK for Node.js
+
+Official Node.js client for [SafetyGates](https://cyclecore.ai/safetygates) content moderation API.
+
+## Installation
+
+```bash
+npm install safetygates
+```
+
+## Quick Start
+
+```javascript
+const SafetyGates = require('safetygates');
+
+const client = new SafetyGates('sg_live_your_api_key');
+
+// Classify text
+const result = await client.classify('you suck at this game', ['toxic', 'harassment']);
+console.log(result.results.toxic.label);      // true
+console.log(result.results.toxic.confidence); // 0.92
+
+// Convenience methods
+if (await client.isToxic('some message')) {
+  console.log('Message blocked');
+}
+```
+
+## Get Your API Key
+
+Sign up for free at [sg-api.cyclecore.ai/signup](https://sg-api.cyclecore.ai/signup)
+
+- **Free tier:** 1,000 requests/day
+- **No credit card required**
+
+## API Reference
+
+### Constructor
+
+```javascript
+const client = new SafetyGates(apiKey, options);
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `apiKey` | string | Your API key (required) |
+| `options.baseUrl` | string | API URL (default: `https://sg-api.cyclecore.ai`) |
+| `options.timeout` | number | Request timeout in ms (default: 10000) |
+
+### classify(text, gates)
+
+Classify a single text.
+
+```javascript
+const result = await client.classify('hello world', ['toxic', 'spam']);
+
+// Result:
+{
+  results: {
+    toxic: { label: false, confidence: 0.12 },
+    spam: { label: false, confidence: 0.08 }
+  },
+  latency_us: 1234.5
+}
+```
+
+### classifyBatch(texts, gates)
+
+Classify multiple texts (up to 10,000).
+
+```javascript
+const result = await client.classifyBatch(
+  ['hello', 'you suck', 'nice game'],
+  ['toxic']
+);
+
+// Result:
+{
+  results: [
+    { toxic: { label: false, confidence: 0.1 } },
+    { toxic: { label: true, confidence: 0.94 } },
+    { toxic: { label: false, confidence: 0.05 } }
+  ],
+  total_latency_us: 3456.7,
+  items_per_second: 867.5
+}
+```
+
+### isToxic(text, threshold?)
+
+Convenience method to check toxicity.
+
+```javascript
+if (await client.isToxic(message)) {
+  // Block message
+}
+
+// With custom threshold
+if (await client.isToxic(message, 0.8)) {
+  // Only block if >80% confident
+}
+```
+
+### isSpam(text, threshold?)
+
+Convenience method to check spam.
+
+```javascript
+if (await client.isSpam(message)) {
+  // Block spam
+}
+```
+
+### listGates()
+
+Get available classification gates.
+
+```javascript
+const { gates } = await client.listGates();
+// [{ id: 'toxic', category: 'moderation', ... }, ...]
+```
+
+## Available Gates
+
+| Gate | Language | Description |
+|------|----------|-------------|
+| `toxic` | English | Toxic/abusive content |
+| `spam` | English | Spam/promotional |
+| `hate` | English | Hate speech |
+| `nsfw` | English | Adult content |
+| `harassment` | English | Harassment/bullying |
+| `toxic_es` | Spanish | Toxic content |
+| `spam_es` | Spanish | Spam |
+| `hate_es` | Spanish | Hate speech |
+| `toxic_pt` | Portuguese | Toxic content |
+| `toxic_fr` | French | Toxic content |
+
+Use the `GATES` constant for autocomplete:
+
+```javascript
+const { GATES } = require('safetygates');
+client.classify(text, [GATES.TOXIC, GATES.SPAM]);
+```
+
+## Error Handling
+
+```javascript
+const { SafetyGatesError } = require('safetygates');
+
+try {
+  await client.classify('test', ['invalid_gate']);
+} catch (err) {
+  if (err instanceof SafetyGatesError) {
+    console.log(err.statusCode); // 400
+    console.log(err.detail);     // { detail: "Unknown gates: ['invalid_gate']" }
+  }
+}
+```
+
+## Discord Bot Example
+
+```javascript
+const SafetyGates = require('safetygates');
+const { Client, GatewayIntentBits } = require('discord.js');
+
+const sg = new SafetyGates(process.env.SAFETYGATES_KEY);
+const discord = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages] });
+
+discord.on('messageCreate', async (message) => {
+  if (message.author.bot) return;
+
+  if (await sg.isToxic(message.content, 0.7)) {
+    await message.delete();
+    await message.channel.send(`${message.author}, please keep it civil.`);
+  }
+});
+
+discord.login(process.env.DISCORD_TOKEN);
+```
+
+## TypeScript
+
+Full TypeScript support included:
+
+```typescript
+import SafetyGates, { ClassifyResult, GATES } from 'safetygates';
+
+const client = new SafetyGates('sg_live_xxx');
+const result: ClassifyResult = await client.classify('test', [GATES.TOXIC]);
+```
+
+## Links
+
+- [Documentation](https://sg-api.cyclecore.ai/docs)
+- [Get API Key](https://sg-api.cyclecore.ai/signup)
+- [CycleCore](https://cyclecore.ai)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "safetygates",
+  "version": "0.1.0",
+  "description": "Official SDK for SafetyGates content moderation API",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "content-moderation",
+    "safety",
+    "toxic",
+    "spam",
+    "hate-speech",
+    "moderation",
+    "discord",
+    "gaming",
+    "chat"
+  ],
+  "author": "CycleCore Technologies <hi@cyclecore.ai>",
+  "license": "MIT",
+  "homepage": "https://cyclecore.ai/safetygates",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "src/"
+  ]
+}

package/src/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * SafetyGates SDK TypeScript Definitions
+ *
+ * Copyright (c) 2026 CycleCore Technologies LLC
+ * Licensed under the MIT License
+ */
+
+export interface GateResult {
+  label: boolean;
+  confidence: number;
+}
+
+export interface ClassifyResult {
+  results: Record<string, GateResult>;
+  latency_us: number;
+}
+
+export interface BatchClassifyResult {
+  results: Array<Record<string, GateResult>>;
+  total_latency_us: number;
+  items_per_second: number;
+}
+
+export interface GateInfo {
+  id: string;
+  category: string;
+  description: string;
+  threshold: number;
+}
+
+export interface GatesListResult {
+  gates: GateInfo[];
+}
+
+export interface HealthResult {
+  status: string;
+  gates_loaded: number;
+  available_gates: string[];
+}
+
+export interface SafetyGatesOptions {
+  baseUrl?: string;
+  timeout?: number;
+}
+
+export declare const GATES: {
+  TOXIC: 'toxic';
+  SPAM: 'spam';
+  HATE: 'hate';
+  NSFW: 'nsfw';
+  HARASSMENT: 'harassment';
+  TOXIC_ES: 'toxic_es';
+  SPAM_ES: 'spam_es';
+  HATE_ES: 'hate_es';
+  TOXIC_PT: 'toxic_pt';
+  TOXIC_FR: 'toxic_fr';
+};
+
+export declare class SafetyGatesError extends Error {
+  statusCode: number;
+  detail: any;
+  constructor(message: string, statusCode: number, detail: any);
+}
+
+export declare class SafetyGates {
+  constructor(apiKey: string, options?: SafetyGatesOptions);
+
+  /**
+   * Classify a single text
+   */
+  classify(text: string, gates?: string[]): Promise<ClassifyResult>;
+
+  /**
+   * Classify multiple texts in batch
+   */
+  classifyBatch(texts: string[], gates?: string[]): Promise<BatchClassifyResult>;
+
+  /**
+   * Check if text is toxic (convenience method)
+   */
+  isToxic(text: string, threshold?: number): Promise<boolean>;
+
+  /**
+   * Check if text is spam (convenience method)
+   */
+  isSpam(text: string, threshold?: number): Promise<boolean>;
+
+  /**
+   * Get available gates
+   */
+  listGates(): Promise<GatesListResult>;
+
+  /**
+   * Health check
+   */
+  health(): Promise<HealthResult>;
+}
+
+export default SafetyGates;

package/src/index.js

@@ -0,0 +1,228 @@
+/**
+ * SafetyGates SDK for Node.js
+ * Official client library for the SafetyGates content moderation API
+ *
+ * Copyright (c) 2026 CycleCore Technologies LLC
+ * Licensed under the MIT License
+ * https://cyclecore.ai/safetygates
+ *
+ * @license MIT
+ *
+ * @example
+ * const SafetyGates = require('safetygates');
+ * const client = new SafetyGates('sg_live_xxx');
+ * const result = await client.classify('hello world', ['toxic']);
+ */
+
+const https = require('https');
+const http = require('http');
+
+const DEFAULT_BASE_URL = 'https://sg-api.cyclecore.ai';
+const DEFAULT_TIMEOUT = 10000;
+
+/**
+ * Available classification gates
+ */
+const GATES = {
+  // English
+  TOXIC: 'toxic',
+  SPAM: 'spam',
+  HATE: 'hate',
+  NSFW: 'nsfw',
+  HARASSMENT: 'harassment',
+  // Spanish
+  TOXIC_ES: 'toxic_es',
+  SPAM_ES: 'spam_es',
+  HATE_ES: 'hate_es',
+  // Portuguese
+  TOXIC_PT: 'toxic_pt',
+  // French
+  TOXIC_FR: 'toxic_fr',
+};
+
+class SafetyGatesError extends Error {
+  constructor(message, statusCode, detail) {
+    super(message);
+    this.name = 'SafetyGatesError';
+    this.statusCode = statusCode;
+    this.detail = detail;
+  }
+}
+
+class SafetyGates {
+  /**
+   * Create a SafetyGates client
+   * @param {string} apiKey - Your API key (starts with sg_live_ or sg_test_)
+   * @param {Object} options - Configuration options
+   * @param {string} options.baseUrl - API base URL (default: https://sg-api.cyclecore.ai)
+   * @param {number} options.timeout - Request timeout in ms (default: 10000)
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error('API key is required. Get one at https://sg-api.cyclecore.ai/signup');
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  }
+
+  /**
+   * Make HTTP request to API
+   * @private
+   */
+  _request(method, path, body = null) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const isHttps = url.protocol === 'https:';
+      const lib = isHttps ? https : http;
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.apiKey,
+          'User-Agent': 'safetygates-node/1.0.0',
+        },
+        timeout: this.timeout,
+      };
+
+      const req = lib.request(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new SafetyGatesError(
+                json.detail || 'API error',
+                res.statusCode,
+                json
+              ));
+            } else {
+              resolve(json);
+            }
+          } catch (e) {
+            reject(new SafetyGatesError('Invalid JSON response', res.statusCode, data));
+          }
+        });
+      });
+
+      req.on('error', (e) => {
+        reject(new SafetyGatesError(`Request failed: ${e.message}`, 0, null));
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new SafetyGatesError('Request timeout', 0, null));
+      });
+
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+
+  /**
+   * Classify a single text
+   * @param {string} text - Text to classify
+   * @param {string[]} gates - Gates to check (default: ['toxic'])
+   * @returns {Promise<ClassifyResult>}
+   *
+   * @example
+   * const result = await client.classify('you suck', ['toxic', 'harassment']);
+   * console.log(result.results.toxic.label); // true
+   * console.log(result.results.toxic.confidence); // 0.92
+   */
+  async classify(text, gates = ['toxic']) {
+    if (!text || typeof text !== 'string') {
+      throw new Error('Text must be a non-empty string');
+    }
+    if (!Array.isArray(gates) || gates.length === 0) {
+      throw new Error('Gates must be a non-empty array');
+    }
+
+    return this._request('POST', '/v1/classify', { text, gates });
+  }
+
+  /**
+   * Classify multiple texts in batch
+   * @param {string[]} texts - Array of texts to classify (max 10,000)
+   * @param {string[]} gates - Gates to check (default: ['toxic'])
+   * @returns {Promise<BatchClassifyResult>}
+   *
+   * @example
+   * const result = await client.classifyBatch(
+   *   ['hello', 'you suck', 'nice game'],
+   *   ['toxic']
+   * );
+   * result.results.forEach((r, i) => {
+   *   console.log(`Text ${i}: toxic=${r.toxic.label}`);
+   * });
+   */
+  async classifyBatch(texts, gates = ['toxic']) {
+    if (!Array.isArray(texts) || texts.length === 0) {
+      throw new Error('Texts must be a non-empty array');
+    }
+    if (texts.length > 10000) {
+      throw new Error('Batch size cannot exceed 10,000');
+    }
+    if (!Array.isArray(gates) || gates.length === 0) {
+      throw new Error('Gates must be a non-empty array');
+    }
+
+    return this._request('POST', '/v1/classify/batch', { texts, gates });
+  }
+
+  /**
+   * Check if text is toxic (convenience method)
+   * @param {string} text - Text to check
+   * @param {number} threshold - Confidence threshold (default: 0.5)
+   * @returns {Promise<boolean>}
+   *
+   * @example
+   * if (await client.isToxic('you suck')) {
+   *   console.log('Blocked toxic message');
+   * }
+   */
+  async isToxic(text, threshold = 0.5) {
+    const result = await this.classify(text, ['toxic']);
+    return result.results.toxic.confidence >= threshold;
+  }
+
+  /**
+   * Check if text is spam (convenience method)
+   * @param {string} text - Text to check
+   * @param {number} threshold - Confidence threshold (default: 0.5)
+   * @returns {Promise<boolean>}
+   */
+  async isSpam(text, threshold = 0.5) {
+    const result = await this.classify(text, ['spam']);
+    return result.results.spam.confidence >= threshold;
+  }
+
+  /**
+   * Get available gates
+   * @returns {Promise<GatesListResult>}
+   */
+  async listGates() {
+    return this._request('GET', '/v1/gates');
+  }
+
+  /**
+   * Health check
+   * @returns {Promise<HealthResult>}
+   */
+  async health() {
+    return this._request('GET', '/health');
+  }
+}
+
+// Export class and constants
+module.exports = SafetyGates;
+module.exports.SafetyGates = SafetyGates;
+module.exports.SafetyGatesError = SafetyGatesError;
+module.exports.GATES = GATES;