@recursorsdk/sdk 1.0.0 → 1.0.2

package/dist/mixins/enterprise.js

@@ -0,0 +1,85 @@
+export function EnterpriseMixin(Base) {
+    return class extends Base {
+        // ==================== Projects ====================
+        async createProject(projectData) {
+            return await this.post("/client/projects", projectData);
+        }
+        async getProject(projectId) {
+            return await this.get(`/client/projects/${projectId}`);
+        }
+        async listProjects() {
+            return await this.get("/client/projects");
+        }
+        async updateProject(projectId, updates) {
+            return await this.patch(`/client/projects/${projectId}`, updates);
+        }
+        async deleteProject(projectId) {
+            await this.delete(`/client/projects/${projectId}`);
+        }
+        async getMcpConfig(projectId) {
+            return await this.get(`/client/projects/${projectId}/mcp-config`);
+        }
+        // ==================== Auth & Users ====================
+        async login(credentials) {
+            const response = await this.post("/client/auth/login", credentials);
+            if (response.access_token) {
+                this.setAccessToken(response.access_token);
+            }
+            return response;
+        }
+        async getProfile() {
+            return await this.get("/client/auth/me");
+        }
+        async register(data) {
+            return await this.post("/client/auth/register", data);
+        }
+        async refreshToken(refreshToken) {
+            return await this.post("/client/auth/refresh", { refresh_token: refreshToken });
+        }
+        // ==================== Activity Logs ====================
+        async listActivityLogs(params) {
+            return await this.get("/client/activity", params);
+        }
+        async getUserAuditLogs(limit = 50, offset = 0, action) {
+            const params = { limit, offset };
+            if (action)
+                params.action = action;
+            return await this.get("/client/audit/audit-logs", params);
+        }
+        async exportActivityLogs(format = "csv", start_date, end_date) {
+            // @ts-ignore - access to protected baseUrl
+            const url = new URL(`${this.baseUrl}/client/activity/export`);
+            url.searchParams.set("format", format);
+            if (start_date)
+                url.searchParams.set("start_date", start_date);
+            if (end_date)
+                url.searchParams.set("end_date", end_date);
+            // @ts-ignore - access to protected headers
+            const res = await fetch(url.toString(), { headers: this.headers() });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            return await res.blob();
+        }
+        // ==================== Settings ====================
+        async getSettings() {
+            return await this.get("/client/settings");
+        }
+        async updateAccount(data) {
+            return await this.patch("/client/settings/account", data);
+        }
+        // ==================== Notifications ====================
+        async listNotifications() {
+            return await this.get("/client/notifications");
+        }
+        async markNotificationAsRead(notificationId) {
+            await this.post(`/client/notifications/${notificationId}/read`, {});
+        }
+        // ==================== Billing ====================
+        async getUsage() {
+            return await this.get("/client/billing/usage");
+        }
+        async listBillingPlans() {
+            return await this.get("/client/billing/plans");
+        }
+    };
+}

package/dist/mixins/intelligence.d.ts

@@ -0,0 +1,61 @@
+import { RecursorBase, Constructor } from "../base.js";
+import { IntentResponse, IntentHistoryItem, ChatMessage, ChatGatewayResponse, ChatProxyRequest, ChatProxyResponse } from "../types.js";
+export declare function IntelligenceMixin<TBase extends Constructor<RecursorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        detectIntent(args: {
+            user_request: string;
+            current_file?: string;
+            user_id?: string;
+            project_id?: string;
+            tags?: string[];
+            similar_limit?: number;
+        }): Promise<IntentResponse>;
+        getIntentHistory(limit?: number, project_id?: string): Promise<IntentHistoryItem[]>;
+        predictCorrection(input_text: string, user_id: string, context?: Record<string, any>): Promise<any>;
+        correctCode(code: string, language: string, project_profile?: Record<string, unknown>): Promise<Record<string, unknown>>;
+        correctTests(test_code: string, test_framework: string, language: string): Promise<any>;
+        correctConfig(config: string, config_type: string): Promise<Record<string, unknown>>;
+        correctDocumentation(markdown: string, doc_type?: string): Promise<Record<string, unknown>>;
+        applyAutoCorrections(user_id: string, model_name: string, corrections: Array<Record<string, unknown>>): Promise<Record<string, unknown>>;
+        getTrustScore(user_id: string, model_name: string): Promise<number>;
+        submitFeedback(prediction_id: string, accepted: boolean): Promise<void>;
+        getAutoCorrectStats(user_id: string): Promise<Record<string, unknown>>;
+        getPatterns(user_id?: string): Promise<Array<Record<string, unknown>>>;
+        gatewayChat(args: {
+            provider?: string;
+            model?: string;
+            messages: ChatMessage[];
+            call_provider?: boolean;
+            user_id?: string;
+        }): Promise<ChatGatewayResponse>;
+        chatProxy(request: ChatProxyRequest): Promise<ChatProxyResponse>;
+        getLLMGatewayPolicy(): Promise<any>;
+        getRoboticsGatewayPolicy(): Promise<any>;
+        getAvGatewayPolicy(): Promise<any>;
+        listCorrections(args: {
+            page?: number;
+            page_size?: number;
+        }): Promise<any>;
+        searchCorrections(query: string, limit?: number): Promise<any[]>;
+        createCorrection(data: {
+            input_text: string;
+            output_text: string;
+        }): Promise<any>;
+        baseUrl: string;
+        apiKey?: string;
+        accessToken?: string;
+        timeoutMs: number;
+        wsClient?: any;
+        localIndex: Record<string, any>;
+        offlineQueue: any[];
+        setAccessToken(token: string): void;
+        setApiKey(key: string): void;
+        headers(): import("../types.js").HeadersInit;
+        get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+        post<T>(path: string, body?: unknown, method?: string): Promise<T>;
+        put<T>(path: string, body?: unknown): Promise<T>;
+        patch<T>(path: string, body?: unknown): Promise<T>;
+        delete<T>(path: string): Promise<T>;
+        checkHealth(): Promise<boolean>;
+    };
+} & TBase;

package/dist/mixins/intelligence.js

@@ -0,0 +1,94 @@
+export function IntelligenceMixin(Base) {
+    return class extends Base {
+        // ==================== Code Intelligence ====================
+        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,
+            };
+            return await this.post("/client/code_intelligence/detect-intent", payload);
+        }
+        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 predictCorrection(input_text, user_id, context = {}) {
+            const body = { input_text, user_id, context };
+            return await this.post("/client/code_intelligence/predict", body);
+        }
+        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 correctTests(test_code, test_framework, language) {
+            const body = { test_code, test_framework, language };
+            return await this.post("/client/code_intelligence/correct/tests", 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 });
+            return typeof data?.trust_score === "number" ? data.trust_score : 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 : [];
+        }
+        // ==================== LLM & Gateways ====================
+        async gatewayChat(args) {
+            const body = {
+                provider: args.provider ?? "gradient",
+                model: args.model ?? undefined,
+                messages: (args.messages ?? []).map(m => ({ role: m.role, content: String(m.content).slice(0, 4000) })),
+                call_provider: !!(args.call_provider ?? true),
+                user_id: args.user_id ?? undefined,
+            };
+            return await this.post("/recursor/llm/gateway/chat", body);
+        }
+        async chatProxy(request) {
+            return await this.post("/client/proxy/chat", request);
+        }
+        async getLLMGatewayPolicy() {
+            return await this.get("/recursor/llm/gateway/policy");
+        }
+        async getRoboticsGatewayPolicy() {
+            return await this.get("/recursor/robotics/gateway/policy");
+        }
+        async getAvGatewayPolicy() {
+            return await this.get("/recursor/av/gateway/policy");
+        }
+        // ==================== Corrections ====================
+        async listCorrections(args) {
+            return await this.get("/client/corrections", args);
+        }
+        async searchCorrections(query, limit = 5) {
+            return await this.get("/client/corrections/search", { query, limit });
+        }
+        async createCorrection(data) {
+            return await this.post("/client/corrections", data);
+        }
+    };
+}

package/dist/mixins/websocket.d.ts

@@ -0,0 +1,25 @@
+import { RecursorBase, Constructor } from "../base.js";
+export declare function WebSocketMixin<TBase extends Constructor<RecursorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        createWebSocket(): Promise<import("../websocket.js").RecursorWebSocket>;
+        connectWebSocket(): Promise<import("../websocket.js").RecursorWebSocket>;
+        disconnectWebSocket(): void;
+        close(): void;
+        baseUrl: string;
+        apiKey?: string;
+        accessToken?: string;
+        timeoutMs: number;
+        wsClient?: any;
+        localIndex: Record<string, any>;
+        offlineQueue: any[];
+        setAccessToken(token: string): void;
+        setApiKey(key: string): void;
+        headers(): import("../types.js").HeadersInit;
+        get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+        post<T>(path: string, body?: unknown, method?: string): Promise<T>;
+        put<T>(path: string, body?: unknown): Promise<T>;
+        patch<T>(path: string, body?: unknown): Promise<T>;
+        delete<T>(path: string): Promise<T>;
+        checkHealth(): Promise<boolean>;
+    };
+} & TBase;

package/dist/mixins/websocket.js

@@ -0,0 +1,28 @@
+export function WebSocketMixin(Base) {
+    return class extends Base {
+        async createWebSocket() {
+            if (!this.accessToken)
+                throw new Error("Access token required");
+            if (!this.wsClient) {
+                // Dynamic import to avoid circular dependency issues if websocket.ts imports RecursorSDK
+                const { RecursorWebSocket } = await import("../websocket.js");
+                this.wsClient = new RecursorWebSocket(this.baseUrl, this.accessToken);
+            }
+            return this.wsClient;
+        }
+        async connectWebSocket() {
+            const ws = await this.createWebSocket();
+            await ws.connect();
+            return ws;
+        }
+        disconnectWebSocket() {
+            if (this.wsClient) {
+                this.wsClient.disconnect();
+                this.wsClient = undefined;
+            }
+        }
+        close() {
+            this.disconnectWebSocket();
+        }
+    };
+}

package/dist/mixins/workflows.d.ts

@@ -0,0 +1,26 @@
+import { RecursorBase, Constructor } from "../base.js";
+import { WorkflowCreate, WorkflowResponse, WorkflowExecutionResponse } from "../types.js";
+export declare function WorkflowMixin<TBase extends Constructor<RecursorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        createWorkflow(data: WorkflowCreate): Promise<WorkflowResponse>;
+        listWorkflows(): Promise<WorkflowResponse[]>;
+        executeWorkflow(workflowId: string, inputData: Record<string, any>): Promise<WorkflowExecutionResponse>;
+        getExecutionStatus(executionId: string): Promise<WorkflowExecutionResponse>;
+        baseUrl: string;
+        apiKey?: string;
+        accessToken?: string;
+        timeoutMs: number;
+        wsClient?: any;
+        localIndex: Record<string, any>;
+        offlineQueue: any[];
+        setAccessToken(token: string): void;
+        setApiKey(key: string): void;
+        headers(): import("../types.js").HeadersInit;
+        get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+        post<T>(path: string, body?: unknown, method?: string): Promise<T>;
+        put<T>(path: string, body?: unknown): Promise<T>;
+        patch<T>(path: string, body?: unknown): Promise<T>;
+        delete<T>(path: string): Promise<T>;
+        checkHealth(): Promise<boolean>;
+    };
+} & TBase;

package/dist/mixins/workflows.js

@@ -0,0 +1,16 @@
+export function WorkflowMixin(Base) {
+    return class extends Base {
+        async createWorkflow(data) {
+            return await this.post("/client/workflows/", data);
+        }
+        async listWorkflows() {
+            return await this.get("/client/workflows/");
+        }
+        async executeWorkflow(workflowId, inputData) {
+            return await this.post(`/client/workflows/${workflowId}/execute`, inputData);
+        }
+        async getExecutionStatus(executionId) {
+            return await this.get(`/client/workflows/executions/${executionId}`);
+        }
+    };
+}

package/dist/plugins/windsurfStub.d.ts

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

package/dist/plugins/windsurfStub.js

@@ -1,12 +1,12 @@
 import { RecursorSDK } from "../index";
-export async function initAgentSession(userId, orgId) {
+export async function initAgentSession(userId) {
     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 });
+        await sdk.gatewayChat({ provider: "openai", model: undefined, messages, call_provider: false, user_id: userId });
     }
     catch (e) {
         // silent fail to avoid disrupting agent

package/dist/types.d.ts

@@ -0,0 +1,204 @@
+export type HeadersInit = Record<string, string>;
+export interface IntentResponse {
+    action: string;
+    scope: string[];
+    constraints: Record<string, unknown>;
+    quality: string;
+    preserve_existing: boolean;
+    similar_past_requests: string[];
+}
+export interface ChatMessage {
+    role: string;
+    content: string;
+}
+export interface ChatGatewayResponse {
+    policy: Record<string, unknown>;
+    normalized_messages: ChatMessage[];
+    provider_response?: Record<string, unknown>;
+}
+export interface RoboticsGatewayResponse {
+    policy: Record<string, unknown>;
+    result: Record<string, unknown>;
+}
+export interface AVGatewayResponse {
+    policy: Record<string, unknown>;
+    result: Record<string, unknown>;
+}
+export interface IntentHistoryItem {
+    id: string;
+    text: string;
+    created_at: string;
+    project_id?: string | null;
+    tags?: string[];
+}
+export interface CorrectionResponseList {
+    corrections: unknown[];
+    total: number;
+    page: number;
+    page_size: number;
+}
+export interface UserRegister {
+    email: string;
+    password: string;
+    full_name?: string;
+    username: string;
+}
+export interface UserLogin {
+    email: string;
+    password: string;
+}
+export interface TokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    token_type: string;
+    expires_in: number;
+}
+export interface UserProfile {
+    id: string;
+    email: string;
+    username: string;
+    full_name?: string;
+    role: string;
+    is_active: boolean;
+    is_verified: boolean;
+    created_at: string;
+    last_login?: string;
+}
+export interface UserResponse {
+    id: string;
+    email: string;
+    username: string;
+    full_name?: string;
+    created_at: string;
+}
+export interface UserUpdate {
+    full_name?: string;
+    username?: string;
+}
+export interface PasswordChange {
+    current_password: string;
+    new_password: string;
+}
+export interface APIKeyResponse {
+    api_key: string;
+    created_at: string;
+}
+export interface ProjectCreate {
+    name: string;
+    description?: string;
+    settings?: Record<string, unknown>;
+}
+export interface ProjectUpdate {
+    name?: string;
+    description?: string;
+    settings?: Record<string, unknown>;
+    is_active?: boolean;
+}
+export interface ProjectResponse {
+    id: string;
+    name: string;
+    description?: string;
+    created_by?: string;
+    api_key?: string;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    settings?: Record<string, unknown>;
+}
+export interface UsageStatsResponse {
+    api_calls: {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    corrections: {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    storage_gb: {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    llm_tokens: {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    cost: {
+        current_period: number;
+        estimated_monthly: number;
+    };
+    subscription: {
+        plan_name: string;
+        status: string;
+        billing_period: string;
+    };
+}
+export interface BillingPlanResponse {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    price_monthly: number;
+    price_yearly: number;
+    features: string[];
+}
+export interface NotificationResponse {
+    id: string;
+    type: string;
+    title: string;
+    message: string;
+    is_read: boolean;
+    created_at: string;
+}
+export interface CodebaseIndexResponse {
+    files: number;
+    size: number;
+    last_updated: string;
+}
+export interface WorkflowCreate {
+    name: string;
+    steps: unknown[];
+}
+export interface WorkflowResponse {
+    id: string;
+    name: string;
+    created_at: string;
+    updated_at: string;
+    steps: unknown[];
+}
+export interface WorkflowExecutionResponse {
+    id: string;
+    status: string;
+    results?: Record<string, any>;
+    steps?: any[];
+}
+export interface AuditLog {
+    id: string;
+    action: string;
+    timestamp: string;
+    details: Record<string, any>;
+}
+export interface AuditLogResponse {
+    logs: AuditLog[];
+    user_id: string;
+    limit: number;
+    offset: number;
+}
+export interface ChatProxyRequest {
+    model: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+}
+export interface ChatProxyResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: any[];
+    usage: Record<string, number>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursorsdk/sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Recursor SDK for Node.js",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,9 @@
     "prepare": "npm run build",
     "prepublishOnly": "npm run clean && npm run build"
   },
+  "bin": {
+    "recursor-sdk": "./dist/cli.js"
+  },
   "engines": {
     "node": ">=18"
   },