@recursorsdk/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,480 @@
+export { RecursorWebSocket } from "./websocket.js";
+export class RecursorSDK {
+    constructor(options) {
+        const envBase = process.env.RECURSOR_API_URL ?? "http://localhost:8000/api/v1";
+        this.baseUrl = (options?.baseUrl ?? envBase).replace(/\/$/, "");
+        this.apiKey = options?.apiKey ?? process.env.RECURSOR_API_KEY;
+        this.accessToken = options?.accessToken ?? process.env.RECURSOR_ACCESS_TOKEN;
+        this.timeoutMs = options?.timeoutMs ?? 10000;
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+    }
+    setApiKey(key) {
+        this.apiKey = key;
+    }
+    headers() {
+        const h = { "Content-Type": "application/json" };
+        if (this.accessToken) {
+            h["Authorization"] = `Bearer ${this.accessToken}`;
+        }
+        else if (this.apiKey) {
+            h["X-API-Key"] = this.apiKey;
+        }
+        return h;
+    }
+    async get(path, params) {
+        const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : "/" + path}`);
+        if (params)
+            Object.entries(params).forEach(([k, v]) => {
+                if (v !== undefined && v !== null)
+                    url.searchParams.set(k, String(v));
+            });
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(url, { headers: this.headers(), signal: ctrl.signal });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(t);
+        }
+    }
+    async post(path, body, method = "POST") {
+        const url = `${this.baseUrl}${path.startsWith("/") ? path : "/" + path}`;
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers: this.headers(),
+                body: body ? JSON.stringify(body) : undefined,
+                signal: ctrl.signal,
+            });
+            if (!res.ok) {
+                const errorText = await res.text();
+                throw new Error(`HTTP ${res.status}: ${errorText}`);
+            }
+            // Handle 204 No Content
+            if (res.status === 204)
+                return undefined;
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(t);
+        }
+    }
+    async put(path, body) {
+        return this.post(path, body, "PUT");
+    }
+    async patch(path, body) {
+        return this.post(path, body, "PATCH");
+    }
+    async delete(path) {
+        return this.post(path, undefined, "DELETE");
+    }
+    async checkHealth() {
+        try {
+            const res = await fetch(`${this.baseUrl.replace('/api/v1', '')}/v1/status/health`);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async detectIntent(args) {
+        const payload = {
+            user_request: (args.user_request ?? "").trim().slice(0, 4000),
+            current_file: args.current_file ?? null,
+            user_id: args.user_id ?? null,
+            project_id: args.project_id ?? null,
+            tags: args.tags ?? [],
+            similar_limit: args.similar_limit ?? 5,
+            organization_id: args.organization_id ?? null,
+        };
+        return await this.post("/client/code_intelligence/detect-intent", payload);
+    }
+    // LLM Gateway
+    async getLLMGatewayPolicy() {
+        return await this.get("/recursor/llm/gateway/policy");
+    }
+    async gatewayChat(args) {
+        const body = {
+            provider: args.provider ?? "openai",
+            model: args.model ?? undefined,
+            messages: (args.messages ?? []).map(m => ({ role: m.role, content: String(m.content).slice(0, 4000) })),
+            call_provider: !!(args.call_provider ?? false),
+            user_id: args.user_id ?? undefined,
+            organization_id: args.organization_id ?? undefined,
+        };
+        return await this.post("/recursor/llm/gateway/chat", body);
+    }
+    // Robotics Gateway
+    async getRoboticsGatewayPolicy() {
+        return await this.get("/recursor/robotics/gateway/policy");
+    }
+    async roboticsGatewayObserve(args) {
+        const body = {
+            state: args.state,
+            command: args.command ?? undefined,
+            environment: args.environment ?? [],
+            user_id: args.user_id ?? undefined,
+            organization_id: args.organization_id ?? undefined,
+        };
+        return await this.post("/recursor/robotics/gateway/observe", body);
+    }
+    // AV Gateway
+    async getAvGatewayPolicy() {
+        return await this.get("/recursor/av/gateway/policy");
+    }
+    async avGatewayObserve(args) {
+        const body = {
+            sensors: args.sensors,
+            state: args.state,
+            action: args.action,
+            timestamp: args.timestamp,
+            vehicle_id: args.vehicle_id,
+            user_id: args.user_id ?? undefined,
+            organization_id: args.organization_id ?? undefined,
+        };
+        return await this.post("/recursor/av/gateway/observe", body);
+    }
+    async getIntentHistory(limit = 50, project_id) {
+        const params = { limit: Math.max(1, Math.min(limit, 200)) };
+        if (project_id)
+            params.project_id = project_id;
+        return await this.get("/client/code_intelligence/intent-history", params);
+    }
+    async createCorrection(args) {
+        const body = {
+            input_text: (args.input_text ?? "").slice(0, 4000),
+            output_text: (args.output_text ?? "").slice(0, 4000),
+            expected_output: (args.expected_output ?? args.output_text ?? "").slice(0, 4000),
+            context: args.context ?? {},
+            correction_type: args.correction_type ?? null,
+        };
+        const path = args.organization_id
+            ? `/client/corrections/?organization_id=${encodeURIComponent(args.organization_id)}`
+            : "/client/corrections/";
+        return await this.post(path, body);
+    }
+    async listCorrections(args) {
+        const params = {
+            page: Math.max(1, args?.page ?? 1),
+            page_size: Math.max(1, Math.min(args?.page_size ?? 50, 100)),
+            include_inactive: !!(args?.include_inactive ?? false),
+        };
+        if (args?.organization_id)
+            params.organization_id = args.organization_id;
+        return await this.get("/client/corrections/", params);
+    }
+    async searchCorrections(query, limit = 10, organization_id) {
+        const params = {
+            query: (query ?? "").trim().slice(0, 4000),
+            limit: Math.max(1, Math.min(limit, 50)),
+        };
+        if (organization_id)
+            params.organization_id = organization_id;
+        return await this.get("/client/corrections/search", params);
+    }
+    async getAnalyticsDashboard(user_id, period = "30d", project_id) {
+        const params = { user_id, period };
+        if (project_id)
+            params.project_id = project_id;
+        return await this.get("/client/code_intelligence/analytics/dashboard", params);
+    }
+    async getTimeSaved(user_id, period = "30d", project_id) {
+        const params = { user_id, period };
+        if (project_id)
+            params.project_id = project_id;
+        return await this.get("/client/code_intelligence/analytics/time-saved", params);
+    }
+    async getQualityMetrics(user_id, period = "30d", project_id) {
+        const params = { user_id, period };
+        if (project_id)
+            params.project_id = project_id;
+        return await this.get("/client/code_intelligence/analytics/quality", params);
+    }
+    async getAIAgentMetrics(user_id, project_id) {
+        const params = { user_id };
+        if (project_id)
+            params.project_id = project_id;
+        return await this.get("/client/code_intelligence/analytics/ai-agent", params);
+    }
+    async correctCode(code, language, project_profile) {
+        const body = { code, language, project_profile: project_profile ?? {} };
+        return await this.post("/client/code_intelligence/correct/code", body);
+    }
+    async correctConfig(config, config_type) {
+        const body = { config, config_type };
+        return await this.post("/client/code_intelligence/correct/config", body);
+    }
+    async correctDocumentation(markdown, doc_type = "README") {
+        const body = { markdown, doc_type };
+        return await this.post("/client/code_intelligence/correct/documentation", body);
+    }
+    async applyAutoCorrections(user_id, model_name, corrections) {
+        const body = { user_id, model_name, corrections };
+        return await this.post("/client/code_intelligence/auto-correct", body);
+    }
+    async getTrustScore(user_id, model_name) {
+        const data = await this.get("/client/code_intelligence/trust-score", { user_id, model_name });
+        const v = data.trust_score;
+        return typeof v === "number" ? v : Number(v ?? 0);
+    }
+    async submitFeedback(prediction_id, accepted) {
+        await this.post("/client/code_intelligence/feedback", { prediction_id, accepted: !!accepted });
+    }
+    async getAutoCorrectStats(user_id) {
+        return await this.get("/client/code_intelligence/stats", { user_id });
+    }
+    async getPatterns(user_id) {
+        const params = user_id ? { user_id } : undefined;
+        const data = await this.get("/client/code_intelligence/patterns", params);
+        return Array.isArray(data) ? data : [];
+    }
+    // ==================== Authentication & User Management ====================
+    async register(userData) {
+        return await this.post("/client/auth/register", userData);
+    }
+    async login(credentials) {
+        const response = await this.post("/client/auth/login", credentials);
+        // Automatically set access token for future requests
+        if (response.access_token) {
+            this.setAccessToken(response.access_token);
+            // Update WebSocket token if connected
+            if (this.wsClient) {
+                this.wsClient.updateToken(response.access_token);
+            }
+        }
+        return response;
+    }
+    async logout() {
+        await this.post("/client/auth/logout", {});
+    }
+    async refreshToken(refreshToken) {
+        return await this.post("/client/auth/refresh", { refresh_token: refreshToken });
+    }
+    async getProfile() {
+        return await this.get("/client/auth/me");
+    }
+    async updateProfile(updates) {
+        return await this.put("/client/auth/me", updates);
+    }
+    async changePassword(passwordChange) {
+        await this.post("/client/auth/change-password", passwordChange);
+    }
+    async generateApiKey() {
+        return await this.post("/client/auth/api-key", {});
+    }
+    async revokeApiKey() {
+        await this.delete("/client/auth/api-key");
+    }
+    async getPasswordRequirements() {
+        return await this.get("/client/auth/password-requirements");
+    }
+    // ==================== Project Management ====================
+    async createProject(projectData) {
+        return await this.post("/client/projects/", projectData);
+    }
+    async getProject(projectId) {
+        return await this.get(`/client/projects/${projectId}`);
+    }
+    async listProjects(organizationId) {
+        const path = organizationId ? `/client/projects/org/${organizationId}` : "/client/projects/";
+        return await this.get(path);
+    }
+    async updateProject(projectId, updates) {
+        return await this.patch(`/client/projects/${projectId}`, updates);
+    }
+    async deleteProject(projectId) {
+        await this.delete(`/client/projects/${projectId}`);
+    }
+    async regenerateProjectApiKey(projectId) {
+        return await this.post(`/client/projects/${projectId}/api-key`, {});
+    }
+    async getMcpConfig(projectId) {
+        return await this.get(`/client/projects/${projectId}/mcp-config`);
+    }
+    async getMcpStats(projectId) {
+        return await this.get(`/client/projects/${projectId}/mcp-stats`);
+    }
+    // ==================== Organizations & Teams ====================
+    async createOrganization(orgData) {
+        return await this.post("/client/organizations/", orgData);
+    }
+    async listOrganizations() {
+        return await this.get("/client/organizations/");
+    }
+    async getOrganization(orgId) {
+        return await this.get(`/client/organizations/${orgId}`);
+    }
+    async updateOrganization(orgId, updates) {
+        return await this.put(`/client/organizations/${orgId}`, updates);
+    }
+    async addMemberToOrganization(orgId, userId) {
+        await this.post(`/client/organizations/${orgId}/members`, { user_id: userId });
+    }
+    async removeMemberFromOrganization(orgId, userId) {
+        await this.post(`/client/organizations/${orgId}/members/${userId}`, {});
+    }
+    // ==================== Billing & Usage ====================
+    async getUsage() {
+        return await this.get("/client/billing/usage");
+    }
+    async getUsageHistory(days = 30, resourceType) {
+        const params = { days };
+        if (resourceType)
+            params.resource_type = resourceType;
+        return await this.get("/client/billing/usage/history", params);
+    }
+    async listBillingPlans() {
+        const data = await this.get("/client/billing/plans");
+        return Array.isArray(data.plans) ? data.plans : [];
+    }
+    async getSubscription() {
+        return await this.get("/client/billing/subscription");
+    }
+    // ==================== Notifications ====================
+    async listNotifications() {
+        const data = await this.get("/client/notifications");
+        return Array.isArray(data.notifications) ? data.notifications : [];
+    }
+    async markNotificationAsRead(notificationId) {
+        return await this.post(`/client/notifications/${notificationId}/read`, {});
+    }
+    async markAllNotificationsAsRead() {
+        await this.post("/client/notifications/read-all", {});
+    }
+    async deleteNotification(notificationId) {
+        await this.delete(`/client/notifications/${notificationId}`);
+    }
+    // ==================== Settings ====================
+    async getSettings() {
+        return await this.get("/client/settings");
+    }
+    async updateAccount(updates) {
+        return await this.put("/client/settings/account", updates);
+    }
+    async updatePreferences(preferences) {
+        return await this.put("/client/settings/preferences", preferences);
+    }
+    async getGuidelines() {
+        return await this.get("/client/settings/guidelines");
+    }
+    async changePasswordViaSettings(passwordChange) {
+        await this.post("/client/settings/password", passwordChange);
+    }
+    async deleteAccount(confirm) {
+        await this.delete("/client/settings/account");
+    }
+    // ==================== Activity Logs ====================
+    async listActivityLogs(page = 1, pageSize = 50) {
+        return await this.get("/client/activity", { page, page_size: pageSize });
+    }
+    async exportActivityLogs() {
+        const url = `${this.baseUrl}/client/activity/export`;
+        const res = await fetch(url, { headers: this.headers() });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        return await res.blob();
+    }
+    // ==================== Corrections (Additional Methods) ====================
+    async getCorrection(correctionId) {
+        return await this.get(`/client/corrections/${correctionId}`);
+    }
+    async updateCorrection(correctionId, updates) {
+        return await this.put(`/client/corrections/${correctionId}`, updates);
+    }
+    async getCorrectionStats() {
+        return await this.get("/client/corrections/stats");
+    }
+    // ==================== WebSocket Support ====================
+    /**
+     * Create WebSocket connection for real-time updates
+     * Requires access token (use login() first or setAccessToken())
+     */
+    async createWebSocket() {
+        if (!this.accessToken) {
+            throw new Error("Access token required for WebSocket connection. Use login() first or setAccessToken()");
+        }
+        if (!this.wsClient) {
+            // Dynamic import for WebSocket
+            const { RecursorWebSocket } = await import("./websocket.js");
+            this.wsClient = new RecursorWebSocket(this.baseUrl, this.accessToken);
+        }
+        return this.wsClient;
+    }
+    /**
+     * Connect WebSocket and return client
+     */
+    async connectWebSocket() {
+        const ws = await this.createWebSocket();
+        await ws.connect();
+        return ws;
+    }
+    /**
+     * Disconnect WebSocket if connected
+     */
+    disconnectWebSocket() {
+        if (this.wsClient) {
+            this.wsClient.disconnect();
+            this.wsClient = undefined;
+        }
+    }
+    // ==================== Memory Operations ====================
+    /**
+     * Create a conversation summary
+     */
+    async createConversationSummary(data) {
+        return this.post("/client/memory/conversations/summaries", data);
+    }
+    /**
+     * Get a conversation summary by ID
+     */
+    async getConversationSummary(conversationId) {
+        return this.get(`/client/memory/conversations/summaries/${conversationId}`);
+    }
+    /**
+     * List recent conversation summaries
+     */
+    async listConversationSummaries(params) {
+        return this.get("/client/memory/conversations/summaries", params);
+    }
+    /**
+     * Record an architectural change
+     */
+    async recordArchitecturalChange(data) {
+        return this.post("/client/memory/architectural/changes", data);
+    }
+    /**
+     * List recent architectural changes
+     */
+    async listArchitecturalChanges(params) {
+        return this.get("/client/memory/architectural/changes", params);
+    }
+    // ==================== Rotatable Memory Operations ====================
+    /**
+     * Query rotatable memory patterns
+     */
+    async queryRotatableMemory(params) {
+        return this.post("/client/memory/rotatable/query", params || {});
+    }
+    /**
+     * Record pattern usage and update effectiveness
+     */
+    async recordPatternUsage(patternId, successful) {
+        return this.post("/client/memory/rotatable/usage", {
+            pattern_id: patternId,
+            successful,
+        });
+    }
+    /**
+     * Get rotatable memory statistics
+     */
+    async getRotatableMemoryStats() {
+        return this.get("/client/memory/rotatable/stats");
+    }
+}

package/dist/plugins/vscodeStub.d.ts

@@ -0,0 +1,2 @@
+export declare function activate(): Promise<void>;
+export declare function deactivate(): void;

package/dist/plugins/vscodeStub.js

@@ -0,0 +1,24 @@
+import { RecursorSDK } from "../index";
+export async function activate() {
+    const sdk = new RecursorSDK();
+    try {
+        const policy = await sdk.getLLMGatewayPolicy();
+        const messages = [
+            { role: "system", content: "Agent start: enforce governance and consistency" },
+        ];
+        await sdk.gatewayChat({ provider: "openai", model: undefined, messages, call_provider: false });
+        // Optionally pre-warm robotics/av policies for domain projects
+        try {
+            await sdk.getRoboticsGatewayPolicy();
+        }
+        catch { }
+        try {
+            await sdk.getAvGatewayPolicy();
+        }
+        catch { }
+    }
+    catch (e) {
+        // noop – extension should not crash if server unavailable
+    }
+}
+export function deactivate() { }

package/dist/plugins/windsurfStub.d.ts

@@ -0,0 +1 @@
+export declare function initAgentSession(userId?: string, orgId?: string): Promise<void>;

package/dist/plugins/windsurfStub.js

@@ -0,0 +1,14 @@
+import { RecursorSDK } from "../index";
+export async function initAgentSession(userId, orgId) {
+    const sdk = new RecursorSDK();
+    try {
+        const policy = await sdk.getLLMGatewayPolicy();
+        const messages = [
+            { role: "system", content: "Windsurf agent: route through Recursor gateway" },
+        ];
+        await sdk.gatewayChat({ provider: "openai", model: undefined, messages, call_provider: false, user_id: userId, organization_id: orgId });
+    }
+    catch (e) {
+        // silent fail to avoid disrupting agent
+    }
+}

package/dist/websocket.d.ts

@@ -0,0 +1,73 @@
+/**
+ * WebSocket Client for Recursor SDK
+ * Provides real-time updates via WebSocket connection
+ */
+export interface WebSocketMessage {
+    type: string;
+    data?: unknown;
+    user_id?: string;
+    timestamp?: string;
+    message?: string;
+}
+export type WebSocketEventHandler = (data: unknown) => void;
+export declare class RecursorWebSocket {
+    private ws;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private pingInterval;
+    private isConnecting;
+    private shouldReconnect;
+    private eventHandlers;
+    private baseUrl;
+    private accessToken;
+    constructor(baseUrl: string, accessToken: string);
+    /**
+     * Connect to WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    private attemptReconnect;
+    /**
+     * Start ping interval to keep connection alive
+     */
+    private startPing;
+    /**
+     * Stop ping interval
+     */
+    private stopPing;
+    /**
+     * Send message to server
+     */
+    send(message: WebSocketMessage): void;
+    /**
+     * Subscribe to event type
+     */
+    on(event: string, handler: WebSocketEventHandler): void;
+    /**
+     * Unsubscribe from event type
+     */
+    off(event: string, handler: WebSocketEventHandler): void;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Emit event to handlers
+     */
+    private emit;
+    /**
+     * Disconnect WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Update access token (useful after token refresh)
+     */
+    updateToken(newToken: string): void;
+}