@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/cjs/index.js

@@ -28,51 +28,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   SDK: () => SDK,
-  createAdminService: () => import_services3.createAdminService,
-  createAuthService: () => import_services3.createAuthService,
-  createBranchService: () => import_services3.createBranchService,
-  createCollabService: () => import_services3.createCollabService,
-  createDnsService: () => import_services3.createDnsService,
-  createFeatureFlagService: () => import_services3.createFeatureFlagService,
-  createFileService: () => import_services3.createFileService,
-  createIntegrationService: () => import_services3.createIntegrationService,
-  createMetricsService: () => import_services3.createMetricsService,
-  createPaymentService: () => import_services3.createPaymentService,
-  createPlanService: () => import_services3.createPlanService,
-  createProjectService: () => import_services3.createProjectService,
-  createPullRequestService: () => import_services3.createPullRequestService,
-  createSubscriptionService: () => import_services3.createSubscriptionService,
-  createTrackingService: () => import_services3.createTrackingService,
-  createWaitlistService: () => import_services3.createWaitlistService,
   default: () => index_default,
-  environment: () => import_environment2.default,
-  isLocalhost: () => isLocalhost
+  environment: () => import_environment2.default
 });
 module.exports = __toCommonJS(index_exports);
 var import_services = require("./services/index.js");
 var import_services2 = require("./utils/services.js");
+var import_SymstoryService = require("./services/SymstoryService.js");
 var import_environment = __toESM(require("./config/environment.js"), 1);
-var import_rootEventBus = require("./state/rootEventBus.js");
-var import_services3 = require("./services/index.js");
 var import_environment2 = __toESM(require("./config/environment.js"), 1);
-const isBrowserEnvironment = () => typeof window !== "undefined";
-const isLocalhost = () => {
-  if (!isBrowserEnvironment()) {
-    return false;
-  }
-  const host = window.location && window.location.hostname;
-  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "" || !host;
-};
 class SDK {
   constructor(options = {}) {
     this._services = /* @__PURE__ */ new Map();
     this._context = {};
     this._options = this._validateOptions(options);
-    this.environment = import_environment.default;
-    this.rootBus = import_rootEventBus.rootBus;
     this._createServiceProxies();
   }
-  // Initialize SDK with context
   async initialize(context = {}) {
     this._context = {
       ...this._context,
@@ -80,121 +51,36 @@ class SDK {
     };
     await Promise.all([
       this._initService(
-        "auth",
-        (0, import_services.createAuthService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "collab",
-        (0, import_services.createCollabService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      // Initialize new modular services
-      this._initService(
-        "project",
-        (0, import_services.createProjectService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "plan",
-        (0, import_services.createPlanService)({
+        "based",
+        (0, import_services.createBasedService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "subscription",
-        (0, import_services.createSubscriptionService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "file",
-        (0, import_services.createFileService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "payment",
-        (0, import_services.createPaymentService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "dns",
-        (0, import_services.createDnsService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "branch",
-        (0, import_services.createBranchService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "pullRequest",
-        (0, import_services.createPullRequestService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "admin",
-        (0, import_services.createAdminService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "screenshot",
-        (0, import_services.createScreenshotService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "tracking",
-        (0, import_services.createTrackingService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "waitlist",
-        (0, import_services.createWaitlistService)({
+        "auth",
+        (0, import_services.createAuthService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "metrics",
-        (0, import_services.createMetricsService)({
+        "socket",
+        (0, import_services.createSocketService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "integration",
-        (0, import_services.createIntegrationService)({
+        "symstory",
+        (0, import_services.createSymstoryService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "featureFlag",
-        (0, import_services.createFeatureFlagService)({
+        "ai",
+        (0, import_services.createAIService)({
           context: this._context,
           options: this._options
         })
@@ -215,33 +101,16 @@ class SDK {
     this._services.set(name, service);
   }
   _validateOptions(options) {
-    const onLocalhost = isLocalhost();
-    const hasGrafanaUrl = Boolean(import_environment.default.grafanaUrl);
     const defaults = {
       useNewServices: true,
       // Use new service implementations by default
-      apiUrl: import_environment.default.apiUrl,
+      baseUrl: import_environment.default.baseUrl,
       socketUrl: import_environment.default.socketUrl,
       timeout: 3e4,
       retryAttempts: 3,
-      debug: false,
-      tracking: {
-        // Force-disabled on localhost or when no Grafana URL is configured
-        enabled: onLocalhost ? false : hasGrafanaUrl ? import_environment.default.features.trackingEnabled : false
-      }
-    };
-    const merged = {
-      ...defaults,
-      ...options,
-      tracking: {
-        ...defaults.tracking,
-        ...options.tracking || {}
-      }
+      debug: false
     };
-    if (onLocalhost || !hasGrafanaUrl) {
-      merged.tracking.enabled = false;
-    }
-    return merged;
+    return { ...defaults, ...options };
   }
   // Get service instance
   getService(name) {
@@ -252,19 +121,22 @@ class SDK {
   }
   // Update context
   updateContext(newContext) {
-    const { ...sanitized } = newContext || {};
     this._context = {
       ...this._context,
-      ...sanitized
+      ...newContext
     };
     for (const service of this._services.values()) {
       service.updateContext(this._context);
+      if (service instanceof import_SymstoryService.SymstoryService) {
+        service.init();
+      }
     }
   }
   // Check if SDK is ready
   isReady() {
-    const sdkServices = Array.from(this._services.values());
-    return sdkServices.length > 0 && sdkServices.every((service) => service.isReady());
+    return Array.from(this._services.values()).every(
+      (service) => service.isReady()
+    );
   }
   // Get SDK status
   getStatus() {
@@ -293,24 +165,5 @@ class SDK {
       }
     }
   }
-  /**
-   * Destroys all services and cleans up resources
-   * @returns {Promise<boolean>} Returns true when cleanup is complete
-   */
-  async destroy() {
-    try {
-      const destroyPromises = Array.from(this._services.entries()).filter(([, service]) => typeof service.destroy === "function").map(async ([name, service]) => {
-        await service.destroy();
-        console.log(`Service ${name} destroyed successfully`);
-      });
-      await Promise.all(destroyPromises);
-      this._services.clear();
-      this._context = {};
-      return true;
-    } catch (error) {
-      console.error("Error during SDK destruction:", error);
-      throw error;
-    }
-  }
 }
 var index_default = SDK;

package/dist/cjs/services/AIService.js

@@ -0,0 +1,155 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AIService_exports = {};
+__export(AIService_exports, {
+  AIService: () => AIService
+});
+module.exports = __toCommonJS(AIService_exports);
+var import_BaseService = require("./BaseService.js");
+class AIService extends import_BaseService.BaseService {
+  constructor(config) {
+    super(config);
+    this._client = null;
+    this._initialized = false;
+    this._defaultConfig = {
+      baseUrl: "https://api.openai.com/v1/engines/text-curie/completions",
+      temperature: 0,
+      maxTokens: 2e3,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+  }
+  init() {
+    try {
+      const { appKey, authToken } = this._context;
+      this._info = {
+        config: {
+          appKey: appKey ? `${appKey.substr(0, 4)}...${appKey.substr(-4)}` : "",
+          hasToken: Boolean(authToken)
+        }
+      };
+      this._initialized = true;
+      this._setReady();
+    } catch (error) {
+      this._setError(error);
+      throw error;
+    }
+  }
+  // Helper to check if method requires initialization
+  _requiresInit(methodName) {
+    const noInitMethods = /* @__PURE__ */ new Set(["getConfig", "validateConfig"]);
+    return !noInitMethods.has(methodName);
+  }
+  // Override _requireReady to be more flexible
+  _requireReady(methodName) {
+    if (this._requiresInit(methodName) && !this._initialized) {
+      throw new Error("AI service not initialized");
+    }
+  }
+  // Configuration methods
+  getConfig() {
+    var _a;
+    return {
+      ...this._defaultConfig,
+      ...(_a = this._context.ai) == null ? void 0 : _a.config
+    };
+  }
+  validateConfig(config = {}) {
+    const requiredFields = ["baseUrl", "temperature", "maxTokens"];
+    const missingFields = requiredFields.filter((field) => !config[field]);
+    if (missingFields.length > 0) {
+      throw new Error(
+        `Missing required configuration fields: ${missingFields.join(", ")}`
+      );
+    }
+    return true;
+  }
+  // AI Methods
+  async prompt(query, opts = {}) {
+    var _a;
+    this._requireReady("prompt");
+    try {
+      const config = this.getConfig();
+      const options = {
+        method: "POST",
+        headers: {
+          ...config.headers,
+          Authorization: `Bearer ${(_a = this._context.ai) == null ? void 0 : _a.authToken}`
+        },
+        body: JSON.stringify({
+          prompt: query,
+          temperature: opts.temperature || config.temperature,
+          max_tokens: opts.maxTokens || config.maxTokens,
+          ...opts
+        })
+      };
+      const response = await this._request(config.baseUrl, options);
+      return response;
+    } catch (error) {
+      throw new Error(`AI prompt failed: ${error.message}`);
+    }
+  }
+  // Helper methods
+  async _request(url, options = {}) {
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this._defaultConfig.headers,
+          ...options.headers
+        }
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.message || "Request failed");
+      }
+      return response.status === 204 ? null : response.json();
+    } catch (error) {
+      throw new Error(`Request failed: ${error.message}`);
+    }
+  }
+  // Context update methods
+  updateAuth(authToken) {
+    this.updateContext({
+      ai: {
+        ...this._context.ai,
+        authToken
+      }
+    });
+  }
+  updateConfig(config) {
+    var _a;
+    this.validateConfig(config);
+    this.updateContext({
+      ai: {
+        ...this._context.ai,
+        config: {
+          ...(_a = this._context.ai) == null ? void 0 : _a.config,
+          ...config
+        }
+      }
+    });
+  }
+  // Cleanup
+  destroy() {
+    this._client = null;
+    this._initialized = false;
+    this._setReady(false);
+  }
+}