spectyra-proxy 1.0.0

package/dist/spectyra-proxy.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+import express from "express";
+import cors from "cors";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DASHBOARD_DIR = path.join(__dirname, 'dashboard');
+const PORT = parseInt(process.env.PROXY_PORT || "3001", 10);
+const DASHBOARD_PORT = parseInt(process.env.DASHBOARD_PORT || "3002", 10);
+const SPECTYRA_API = process.env.SPECTYRA_API_URL || "https://spectyra.up.railway.app/v1";
+const CONFIG_FILE = path.join(__dirname, ".spectyra-proxy-config.json");
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+            return JSON.parse(data);
+        }
+    }
+    catch (error) {
+        console.error("Error loading config:", error);
+    }
+    return null;
+}
+function saveConfig(config) {
+    try {
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        console.error("Error saving config:", error);
+    }
+}
+const stats = {
+    totalRequests: 0,
+    totalTokensSaved: 0,
+    totalCostSaved: 0,
+    requests: [],
+};
+function addStats(savings, model) {
+    stats.totalRequests++;
+    if (savings) {
+        stats.totalTokensSaved += savings.tokens_saved || 0;
+        stats.totalCostSaved += savings.cost_saved_usd || 0;
+        stats.requests.push({
+            timestamp: Date.now(),
+            tokensSaved: savings.tokens_saved || 0,
+            costSaved: savings.cost_saved_usd || 0,
+            pctSaved: savings.pct_saved || 0,
+            model,
+        });
+        if (stats.requests.length > 1000) {
+            stats.requests = stats.requests.slice(-1000);
+        }
+    }
+}
+const app = express();
+app.use(cors());
+app.use(express.json());
+function convertMessagesToSpectyra(messages, format) {
+    if (format === "anthropic") {
+        return messages.map((m) => {
+            let content = "";
+            if (typeof m.content === "string") {
+                content = m.content;
+            }
+            else if (Array.isArray(m.content)) {
+                const textPart = m.content.find((p) => p.type === "text");
+                content = textPart?.text || "";
+            }
+            return {
+                role: m.role === "assistant" ? "assistant" : "user",
+                content,
+            };
+        });
+    }
+    else if (format === "gemini") {
+        return messages.map((m) => {
+            let content = "";
+            if (m.parts && Array.isArray(m.parts)) {
+                content = m.parts.map((p) => p.text || "").join("");
+            }
+            else if (typeof m.content === "string") {
+                content = m.content;
+            }
+            return {
+                role: m.role === "model" ? "assistant" : "user",
+                content,
+            };
+        });
+    }
+    else {
+        return messages.map((m) => ({
+            role: m.role,
+            content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+        }));
+    }
+}
+function convertResponseFromSpectyra(data, format, model) {
+    const responseText = data.response_text || data.responseText || "";
+    const inputTokens = data.usage?.input_tokens || 0;
+    const outputTokens = data.usage?.output_tokens || 0;
+    const totalTokens = data.usage?.total_tokens || 0;
+    const id = data.id || Date.now();
+    if (format === "anthropic") {
+        return {
+            id: `msg-${id}`,
+            type: "message",
+            role: "assistant",
+            content: [{
+                    type: "text",
+                    text: responseText,
+                }],
+            model,
+            stop_reason: "end_turn",
+            stop_sequence: null,
+            usage: {
+                input_tokens: inputTokens,
+                output_tokens: outputTokens,
+            },
+        };
+    }
+    else if (format === "gemini") {
+        return {
+            candidates: [{
+                    content: {
+                        parts: [{
+                                text: responseText,
+                            }],
+                        role: "model",
+                    },
+                    finishReason: "STOP",
+                    safetyRatings: [],
+                }],
+            usageMetadata: {
+                promptTokenCount: inputTokens,
+                candidatesTokenCount: outputTokens,
+                totalTokenCount: totalTokens,
+            },
+        };
+    }
+    else {
+        return {
+            id: `chatcmpl-${id}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content: responseText,
+                    },
+                    finish_reason: "stop",
+                }],
+            usage: {
+                prompt_tokens: inputTokens,
+                completion_tokens: outputTokens,
+                total_tokens: totalTokens,
+            },
+        };
+    }
+}
+function detectApiFormat(req) {
+    const path = req.path;
+    const body = req.body;
+    if (path.includes("/v1/messages")) {
+        return "anthropic";
+    }
+    if (path.includes("/v1/models") || path.includes("generativelanguage")) {
+        return "gemini";
+    }
+    if (path.includes("/v1/chat/completions")) {
+        if (body.messages && Array.isArray(body.messages)) {
+            if (body.messages.some((m) => Array.isArray(m.content))) {
+                return "anthropic";
+            }
+            return "openai";
+        }
+    }
+    return "openai";
+}
+app.post("/v1/chat/completions", async (req, res) => {
+    await handleRequest(req, res, "openai");
+});
+app.post("/v1/messages", async (req, res) => {
+    await handleRequest(req, res, "anthropic");
+});
+app.post("/v1/*/generateContent", async (req, res) => {
+    await handleRequest(req, res, "gemini");
+});
+async function handleRequest(req, res, detectedFormat) {
+    const config = loadConfig();
+    if (!config || !config.spectyraKey || !config.providerKey) {
+        return res.status(500).json({
+            error: {
+                message: "Proxy not configured. Please configure API keys first.",
+                type: "configuration_error",
+            },
+        });
+    }
+    try {
+        const provider = config.provider || (detectedFormat === "anthropic" ? "anthropic" : detectedFormat === "gemini" ? "gemini" : "openai");
+        const format = detectedFormat;
+        let model;
+        let messages;
+        if (format === "anthropic") {
+            model = req.body.model || "claude-3-5-sonnet-20241022";
+            messages = req.body.messages || [];
+            if (req.body.system) {
+                messages.unshift({ role: "system", content: req.body.system });
+            }
+        }
+        else if (format === "gemini") {
+            model = req.body.model || "gemini-pro";
+            const contents = req.body.contents || [];
+            messages = contents.map((c) => ({
+                role: c.role,
+                parts: c.parts || [],
+            }));
+        }
+        else {
+            model = req.body.model || "gpt-4o-mini";
+            messages = req.body.messages || [];
+        }
+        const spectyraMessages = convertMessagesToSpectyra(messages, format);
+        const response = await fetch(`${SPECTYRA_API}/chat`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-SPECTYRA-KEY": config.spectyraKey,
+                "X-PROVIDER-KEY": config.providerKey,
+            },
+            body: JSON.stringify({
+                path: config.path || "code",
+                provider,
+                model,
+                messages: spectyraMessages,
+                mode: "optimized",
+                optimization_level: config.optimizationLevel || 2,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error("Spectyra API error:", response.status, errorText);
+            return res.status(response.status).json({
+                error: {
+                    message: `Spectyra API error: ${response.statusText}`,
+                    type: "api_error",
+                },
+            });
+        }
+        const data = await response.json();
+        if (data.savings) {
+            addStats(data.savings, model);
+            console.log(`💰 Saved ${data.savings.pct_saved?.toFixed(1)}% (${data.savings.tokens_saved} tokens, $${data.savings.cost_saved_usd?.toFixed(4)})`);
+        }
+        const providerResponse = convertResponseFromSpectyra(data, format, model);
+        res.json(providerResponse);
+    }
+    catch (error) {
+        console.error("Proxy error:", error);
+        res.status(500).json({
+            error: {
+                message: error.message || "Internal proxy error",
+                type: "proxy_error",
+            },
+        });
+    }
+}
+app.post("/config", (req, res) => {
+    try {
+        const config = {
+            spectyraKey: req.body.spectyraKey || "",
+            providerKey: req.body.providerKey || "",
+            provider: req.body.provider || "openai",
+            path: req.body.path || "code",
+            optimizationLevel: req.body.optimizationLevel || 2,
+        };
+        saveConfig(config);
+        res.json({ success: true, message: "Configuration saved" });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get("/config", (req, res) => {
+    const config = loadConfig();
+    if (!config) {
+        return res.json({ configured: false });
+    }
+    res.json({
+        configured: true,
+        provider: config.provider,
+        path: config.path,
+        optimizationLevel: config.optimizationLevel,
+    });
+});
+app.get("/stats", (req, res) => {
+    res.json({
+        totalRequests: stats.totalRequests,
+        totalTokensSaved: stats.totalTokensSaved,
+        totalCostSaved: stats.totalCostSaved,
+        recentRequests: stats.requests.slice(-50),
+    });
+});
+app.get("/health", (req, res) => {
+    const config = loadConfig();
+    res.json({
+        status: "ok",
+        service: "spectyra-proxy",
+        configured: !!config && !!config.spectyraKey && !!config.providerKey,
+    });
+});
+app.listen(PORT, () => {
+    console.log(`\n🚀 Spectyra Proxy running on http://localhost:${PORT}`);
+    console.log(`📊 Dashboard: http://localhost:${DASHBOARD_PORT}`);
+    console.log(`🔗 Routing to: ${SPECTYRA_API}`);
+    const config = loadConfig();
+    if (!config || !config.spectyraKey || !config.providerKey) {
+        console.log(`\n⚠️  Proxy not configured!`);
+        console.log(`   Visit http://localhost:${DASHBOARD_PORT} to configure`);
+    }
+    else {
+        console.log(`✅ Proxy configured (${config.provider}, ${config.path} path)`);
+    }
+    console.log(`\n💡 To use with OpenAI-compatible tools, set:`);
+    console.log(`   OPENAI_API_BASE=http://localhost:${PORT}/v1\n`);
+});
+const dashboard = express();
+dashboard.use(cors());
+dashboard.use(express.json());
+dashboard.use(express.static(DASHBOARD_DIR));
+dashboard.get("/api/config", (req, res) => {
+    const config = loadConfig();
+    res.json(config || {});
+});
+dashboard.post("/api/config", (req, res) => {
+    try {
+        const config = {
+            spectyraKey: req.body.spectyraKey || "",
+            providerKey: req.body.providerKey || "",
+            provider: req.body.provider || "openai",
+            path: req.body.path || "code",
+            optimizationLevel: req.body.optimizationLevel || 2,
+        };
+        saveConfig(config);
+        res.json({ success: true });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+dashboard.get("/api/stats", (req, res) => {
+    res.json({
+        totalRequests: stats.totalRequests,
+        totalTokensSaved: stats.totalTokensSaved,
+        totalCostSaved: stats.totalCostSaved,
+        recentRequests: stats.requests.slice(-100),
+    });
+});
+dashboard.get("*", (req, res) => {
+    res.sendFile(path.join(DASHBOARD_DIR, "index.html"));
+});
+dashboard.listen(DASHBOARD_PORT, () => {
+    console.log(`📊 Dashboard running on http://localhost:${DASHBOARD_PORT}`);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "spectyra-proxy",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Local proxy for Spectyra optimization - works with Copilot, Cursor, Claude Code, and other coding assistants",
+  "main": "dist/spectyra-proxy.js",
+  "bin": {
+    "spectyra-proxy": "./dist/spectyra-proxy.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "SETUP_GUIDE.md",
+    "PROVIDER_SUPPORT.md",
+    "INSTALLATION.md",
+    "package.json"
+  ],
+  "scripts": {
+    "dev": "tsx watch spectyra-proxy.ts",
+    "start": "tsx spectyra-proxy.ts",
+    "build": "tsc && node scripts/prepare-dist.js",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node -e \"console.log('✅ Spectyra Proxy installed. Run: spectyra-proxy')\""
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/cors": "^2.8.17",
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "spectyra",
+    "llm",
+    "optimization",
+    "proxy",
+    "copilot",
+    "cursor",
+    "claude"
+  ]
+}