fortress-optimizer 1.0.0

package/README.md

@@ -0,0 +1,185 @@
+# Fortress Token Optimizer - npm Package
+
+Official npm package for integrating Fortress Token Optimizer into your Node.js applications.
+
+## Installation
+
+```bash
+npm install @fortress-optimizer/core
+```
+
+## Quick Start
+
+```javascript
+const { FortressClient } = require('@fortress-optimizer/core');
+
+const client = new FortressClient(process.env.FORTRESS_API_KEY);
+
+// Optimize a prompt
+const result = await client.optimize(
+  'Your prompt here that could be optimized',
+  'balanced',  // 'conservative', 'balanced', or 'aggressive'
+  'openai'     // LLM provider
+);
+
+console.log(`Saved ${result.tokens.savings} tokens!`);
+console.log(`Optimized: ${result.optimization.optimized_prompt}`);
+```
+
+## Features
+
+- ✅ Real-time token optimization
+- ✅ Support for all major LLM providers (OpenAI, Anthropic, Azure, Gemini, Groq, Ollama)
+- ✅ Three optimization levels (conservative, balanced, aggressive)
+- ✅ Token usage tracking
+- ✅ Rate limiting and authentication
+- ✅ TypeScript support
+
+## API Reference
+
+### `FortressClient`
+
+#### Constructor
+```javascript
+new FortressClient(apiKey, options?)
+```
+
+**Parameters:**
+- `apiKey` (string): Your Fortress API key
+- `options` (object, optional):
+  - `baseUrl` (string): API endpoint (default: `https://api.fortress-optimizer.com`)
+  - `timeout` (number): Request timeout in ms (default: 10000)
+
+#### `optimize(prompt, level, provider)`
+
+Optimize a prompt for token efficiency.
+
+**Parameters:**
+- `prompt` (string): The prompt to optimize (max 50,000 characters)
+- `level` (string): 'conservative', 'balanced', or 'aggressive'
+- `provider` (string): LLM provider name
+
+**Returns:** Promise<OptimizationResult>
+
+```javascript
+{
+  request_id: "opt_1707892834.123",
+  status: "success",
+  optimization: {
+    optimized_prompt: "Your optimized prompt...",
+    technique: "deduplication+compression"
+  },
+  tokens: {
+    original: 150,
+    optimized: 120,
+    savings: 30,
+    savings_percentage: 20.0
+  },
+  timestamp: "2026-02-13T14:30:45.123Z"
+}
+```
+
+#### `getUsage()`
+
+Get token usage for your API key.
+
+**Returns:** Promise<UsageStats>
+
+```javascript
+{
+  tokens_used_this_month: 25000,
+  tokens_limit: 50000,
+  tokens_remaining: 25000,
+  percentage_used: 50,
+  reset_date: "2026-03-13T00:00:00Z"
+}
+```
+
+#### `getProviders()`
+
+Get list of supported LLM providers.
+
+**Returns:** Promise<string[]>
+
+#### `healthCheck()`
+
+Check API availability.
+
+**Returns:** Promise<boolean>
+
+## Pricing
+
+- **FREE**: 50,000 tokens/month
+- **PRO**: $9.99/month (unlimited)
+- **TEAM**: $99/month (collaboration features)
+- **ENTERPRISE**: Custom pricing
+
+See [fortress-optimizer.com/pricing](https://fortress-optimizer.com/pricing) for details.
+
+## Examples
+
+### Basic Usage
+```javascript
+const client = new FortressClient(process.env.FORTRESS_API_KEY);
+
+const result = await client.optimize(
+  'Can you explain quantum computing in detail with examples?',
+  'balanced',
+  'openai'
+);
+
+console.log(result);
+```
+
+### Batch Optimization
+```javascript
+const prompts = [
+  'First prompt...',
+  'Second prompt...',
+  'Third prompt...'
+];
+
+const results = await Promise.all(
+  prompts.map(p => client.optimize(p, 'balanced', 'openai'))
+);
+
+results.forEach((r, i) => {
+  console.log(`Prompt ${i}: ${r.tokens.savings_percentage}% saved`);
+});
+```
+
+### Error Handling
+```javascript
+try {
+  const result = await client.optimize(prompt, 'balanced', 'openai');
+} catch (error) {
+  if (error.response?.status === 429) {
+    console.log('Rate limited - wait before retrying');
+  } else if (error.response?.status === 401) {
+    console.log('Invalid API key');
+  } else {
+    console.log('Optimization failed:', error.message);
+  }
+}
+```
+
+## Getting an API Key
+
+1. Sign up at [fortress-optimizer.com](https://fortress-optimizer.com)
+2. Navigate to API Keys
+3. Create a new key
+4. Use in your application
+
+```bash
+export FORTRESS_API_KEY="your-api-key-here"
+```
+
+## Support
+
+- 📖 Documentation: [docs.fortress-optimizer.com](https://docs.fortress-optimizer.com)
+- 💬 Community: [Discord](https://discord.gg/fortress)
+- 📧 Email: support@fortress-optimizer.com
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Fortress Token Optimizer - npm Package
+ * Safe HTTP client wrapper around API
+ * Algorithm is backend-only (never exposed in client code)
+ */
+export interface OptimizationResult {
+    request_id: string;
+    status: 'success' | 'error' | 'rate_limited';
+    optimization: {
+        optimized_prompt: string;
+        technique: string;
+    };
+    tokens: {
+        original: number;
+        optimized: number;
+        savings: number;
+        savings_percentage: number;
+    };
+    timestamp: string;
+}
+export interface UsageStats {
+    tier: string;
+    tokens_optimized: number;
+    tokens_saved: number;
+    requests: number;
+    tokens_limit: number | 'unlimited';
+    tokens_remaining: number | 'unlimited';
+    rate_limit: {
+        requests_this_minute: number;
+        requests_this_day: number;
+        rpm_limit: number;
+        rpd_limit: number;
+    };
+    reset_date: string;
+}
+export interface ClientOptions {
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+export declare class FortressClient {
+    private api;
+    private maxRetries;
+    constructor(apiKey: string, options?: ClientOptions);
+    optimize(prompt: string, level?: 'conservative' | 'balanced' | 'aggressive', provider?: string): Promise<OptimizationResult>;
+    getUsage(): Promise<UsageStats>;
+    getProviders(): Promise<string[]>;
+    healthCheck(): Promise<boolean>;
+    private withRetry;
+    private handleError;
+}
+export default FortressClient;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,cAAc,CAAC;IAC7C,YAAY,EAAE;QACZ,gBAAgB,EAAE,MAAM,CAAC;QACzB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,GAAG,WAAW,CAAC;IACnC,gBAAgB,EAAE,MAAM,GAAG,WAAW,CAAC;IACvC,UAAU,EAAE;QACV,oBAAoB,EAAE,MAAM,CAAC;QAC7B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB;IAmBjD,QAAQ,CACZ,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,cAAc,GAAG,UAAU,GAAG,YAAyB,EAC9D,QAAQ,GAAE,MAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;IAsCxB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAO/B,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAOjC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;YASvB,SAAS;IAyBvB,OAAO,CAAC,WAAW;CAepB;AAED,eAAe,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Fortress Token Optimizer - npm Package
+ * Safe HTTP client wrapper around API
+ * Algorithm is backend-only (never exposed in client code)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FortressClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class FortressClient {
+    constructor(apiKey, options = {}) {
+        const baseUrl = options.baseUrl || 'https://api.fortress-optimizer.com';
+        if (!baseUrl.startsWith('https://') && !baseUrl.startsWith('http://localhost')) {
+            throw new Error('Fortress API requires HTTPS. Use https:// URLs only.');
+        }
+        const timeout = options.timeout || 10000;
+        this.maxRetries = Math.min(options.maxRetries ?? 3, 10);
+        this.api = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'X-Client-Version': '1.0.0',
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async optimize(prompt, level = 'balanced', provider = 'openai') {
+        return this.withRetry(async () => {
+            const response = await this.api.post('/api/optimize', {
+                prompt,
+                level,
+                provider,
+            });
+            const result = response.data;
+            // Validate response integrity — defend against prompt injection
+            if (result.optimization?.optimized_prompt) {
+                const optimized = result.optimization.optimized_prompt;
+                const originalLen = prompt.length;
+                // Reject if optimized is significantly LONGER than original (injection likely)
+                if (optimized.length > originalLen * 2) {
+                    throw new Error('Response validation failed: optimized prompt is suspiciously longer than original');
+                }
+                // Reject if it contains known injection patterns
+                const injectionPatterns = [
+                    'ignore all previous',
+                    'ignore the above',
+                    'disregard prior',
+                    'system prompt',
+                    'you are now',
+                    'new instructions:',
+                ];
+                const lower = optimized.toLowerCase();
+                for (const pattern of injectionPatterns) {
+                    if (lower.includes(pattern) && !prompt.toLowerCase().includes(pattern)) {
+                        throw new Error('Response validation failed: optimized prompt contains suspicious content');
+                    }
+                }
+            }
+            return result;
+        });
+    }
+    async getUsage() {
+        return this.withRetry(async () => {
+            const response = await this.api.get('/api/usage');
+            return response.data;
+        });
+    }
+    async getProviders() {
+        return this.withRetry(async () => {
+            const response = await this.api.get('/api/providers');
+            return response.data.providers;
+        });
+    }
+    async healthCheck() {
+        try {
+            const response = await this.api.get('/health', { timeout: 2000 });
+            return response.status === 200;
+        }
+        catch {
+            return false;
+        }
+    }
+    async withRetry(fn) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                const axiosErr = error;
+                // Don't retry auth errors or bad requests
+                if (axiosErr.response?.status === 401 || axiosErr.response?.status === 400) {
+                    this.handleError(axiosErr);
+                }
+                lastError = error;
+                // Retry on 429 (rate limit) and 5xx with exponential backoff
+                if (attempt < this.maxRetries) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        if (lastError && 'response' in lastError) {
+            this.handleError(lastError);
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+    handleError(error) {
+        if (error.response?.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (error.response?.status === 429) {
+            throw new Error('Rate limited - please wait before retrying');
+        }
+        if (error.response?.status === 400) {
+            throw new Error(`Invalid request: ${error.response.data}`);
+        }
+        if (error.code === 'ECONNABORTED') {
+            throw new Error('Request timeout');
+        }
+        throw new Error(`API error: ${error.message}`);
+    }
+}
+exports.FortressClient = FortressClient;
+exports.default = FortressClient;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "fortress-optimizer",
+  "version": "1.0.0",
+  "description": "Fortress Token Optimizer - npm package for token optimization",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "tokens",
+    "optimization",
+    "llm",
+    "openai",
+    "anthropic",
+    "prompt-engineering"
+  ],
+  "author": "Diawest82",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Diawest82/fortress-optimizer-monorepo"
+  },
+  "homepage": "https://fortress-optimizer.com",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "axios": "1.13.5",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.3",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.8",
+    "ts-jest": "^29.1.1",
+    "eslint": "^8.55.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}