@symbo.ls/sdk 2.34.35 → 3.1.1

package/dist/node/config/environment.js

@@ -1,4 +1,3 @@
-import { isDevelopment } from "@domql/utils";
 const CONFIG = {
   // Common defaults for all environments
   common: {
@@ -7,140 +6,69 @@ const CONFIG = {
     // Feature toggles that apply across all environments by default
     features: {
       newUserOnboarding: true,
-      betaFeatures: false,
-      // Tracking is enabled by default unless overridden per environment
-      trackingEnabled: true
+      betaFeatures: false
     }
   },
   // Environment-specific configurations
   local: {
-    // local
+    baseUrl: "http://localhost:3000",
+    // For symstory api
     socketUrl: "http://localhost:8080",
     // For socket api
-    apiUrl: "http://localhost:8080",
+    routerUrl: "http://localhost:3090",
+    // For router api
+    apiUrl: "http://localhost:13335",
     // For server api
     basedEnv: "development",
     // For based api
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     // For based api
     basedOrg: "symbols",
     // For based api
-    githubClientId: "Ov23liAFrsR0StbAO6PO",
+    githubClientId: "Ov23liHxyWFBxS8f1gnF",
     // For github api
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Localhost",
     // Environment-specific feature toggles (override common)
     features: {
-      // Disable tracking by default on localhost/dev machines
-      trackingEnabled: false,
+      betaFeatures: true
       // Enable beta features in local dev
-      betaFeatures: true,
-      // Preserve common defaults explicitly for local
-      newUserOnboarding: true
-    },
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "vZya3L2zpq8L6iI5WWMUZJZABvT63VDb",
-    typesenseHost: "localhost",
-    typesensePort: "8108",
-    typesenseProtocol: "http"
+    }
   },
   development: {
-    socketUrl: "https://dev.api.symbols.app",
-    apiUrl: "https://dev.api.symbols.app",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Dev",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  testing: {
-    socketUrl: "https://test.api.symbols.app",
-    apiUrl: "https://test.api.symbols.app",
-    basedEnv: "testing",
-    basedProject: "platform-v2-sm",
+    baseUrl: "https://story.symbo.ls",
+    socketUrl: "https://socket.symbols.app",
+    routerUrl: "https://router.symbols.app",
+    apiUrl: "https://api.symbols.app",
+    basedEnv: "development",
+    basedProject: "platform-v2",
     basedOrg: "symbols",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Test",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  upcoming: {
-    socketUrl: "https://upcoming.api.symbols.app",
-    apiUrl: "https://upcoming.api.symbols.app",
-    githubClientId: "Ov23liWF7NvdZ056RV5J",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Upcoming",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
   staging: {
-    socketUrl: "https://staging.api.symbols.app",
+    baseUrl: "https://staging.story.symbo.ls",
+    socketUrl: "https://staging.socket.symbols.app",
+    routerUrl: "https://staging.router.symbols.app",
     apiUrl: "https://staging.api.symbols.app",
     basedEnv: "staging",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23ligwZDQVD0VfuWNa",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Staging",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  preview: {
-    socketUrl: "https://api.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "production",
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols Preview",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23ligwZDQVD0VfuWNa"
   },
   production: {
-    socketUrl: "https://api.symbols.app",
+    baseUrl: "https://story.symbo.ls",
+    socketUrl: "https://socket.symbols.app",
+    routerUrl: "https://router.symbols.app",
     apiUrl: "https://api.symbols.app",
     basedEnv: "production",
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23liFAlOEIXtX3dBtR"
   }
 };
 const getEnvironment = () => {
-  // @preserve-env
-  const env = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
+  const env = process.env.SYMBOLS_APP_ENV || "" || "development";
   if (!CONFIG[env]) {
-    throw new Error(`Unknown environment "${env}"`);
+    console.warn(`Unknown environment "${env}", falling back to development`);
+    return "development";
   }
   return env;
 };
@@ -150,33 +78,25 @@ const getConfig = () => {
     const envConfig = { ...CONFIG.common, ...CONFIG[env] };
     const finalConfig = {
       ...envConfig,
-      // Deep-merge feature flags so env-specific overrides don't drop common defaults
-      features: {
-        ...CONFIG.common.features || {},
-        ...CONFIG[env] && CONFIG[env].features || {}
-      },
+      baseUrl: process.env.SYMBOLS_APP_BASE_URL || envConfig.baseUrl,
       socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
+      routerUrl: process.env.SYMBOLS_APP_ROUTER_URL || envConfig.routerUrl,
       apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
       basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
       basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
       basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
       githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
-      grafanaUrl: process.env.SYMBOLS_APP_GRAFANA_URL || envConfig.grafanaUrl,
-      typesenseCollectionName: process.env.TYPESENSE_COLLECTION_NAME || envConfig.typesenseCollectionName,
-      typesenseApiKey: process.env.TYPESENSE_API_KEY || envConfig.typesenseApiKey,
-      typesenseHost: process.env.TYPESENSE_HOST || envConfig.typesenseHost,
-      typesensePort: process.env.TYPESENSE_PORT || envConfig.typesensePort,
-      typesenseProtocol: process.env.TYPESENSE_PROTOCOL || envConfig.typesenseProtocol,
-      isDevelopment: isDevelopment(env),
-      isTesting: env === "testing",
+      isDevelopment: env === "development" || env === "local",
       isStaging: env === "staging",
-      isPreview: env === "preview",
       isProduction: env === "production"
-      // Store all environment variables for potential future use
     };
     const requiredFields = [
+      "baseUrl",
       "socketUrl",
       "apiUrl",
+      "basedEnv",
+      "basedProject",
+      "basedOrg",
       "githubClientId",
       "googleClientId"
     ];
@@ -187,24 +107,30 @@ const getConfig = () => {
       );
     }
     if (finalConfig.isDevelopment) {
-      console.warn(
+      console.log(
         "environment in SDK:",
-        env || process.env.NODE_ENV || process.env.NODE_ENV
+        env,
+        "",
+        process.env.SYMBOLS_APP_ENV
       );
       console.log(finalConfig);
-    } else if (global.window) {
-      global.window.finalConfig = finalConfig;
     }
     return finalConfig;
   } catch (error) {
     console.error("Failed to load environment configuration:", error);
     return {
-      ...CONFIG.development
+      baseUrl: "https://story.symbo.ls",
+      socketUrl: "https://socket.symbols.app",
+      routerUrl: "https://router.symbols.app",
+      apiUrl: "https://api.symbols.app",
+      basedEnv: "development",
+      basedProject: "platform-v2",
+      basedOrg: "symbols",
+      githubClientId: "Ov23liHxyWFBxS8f1gnF"
     };
   }
 };
 var environment_default = getConfig();
 export {
-  environment_default as default,
-  getConfig
+  environment_default as default
 };

package/dist/node/index.js

@@ -1,43 +1,20 @@
 import {
+  createBasedService,
+  createSymstoryService,
   createAuthService,
-  createCollabService,
-  createProjectService,
-  createPlanService,
-  createFileService,
-  createPaymentService,
-  createDnsService,
-  createBranchService,
-  createPullRequestService,
-  createAdminService,
-  createSubscriptionService,
-  createScreenshotService,
-  createTrackingService,
-  createWaitlistService,
-  createMetricsService,
-  createIntegrationService,
-  createFeatureFlagService
+  createAIService,
+  createSocketService
 } from "./services/index.js";
 import { SERVICE_METHODS } from "./utils/services.js";
+import { SymstoryService } from "./services/SymstoryService.js";
 import environment from "./config/environment.js";
-import { rootBus } from "./state/rootEventBus.js";
-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 = environment;
-    this.rootBus = rootBus;
     this._createServiceProxies();
   }
-  // Initialize SDK with context
   async initialize(context = {}) {
     this._context = {
       ...this._context,
@@ -45,121 +22,36 @@ class SDK {
     };
     await Promise.all([
       this._initService(
-        "auth",
-        createAuthService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "collab",
-        createCollabService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      // Initialize new modular services
-      this._initService(
-        "project",
-        createProjectService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "plan",
-        createPlanService({
+        "based",
+        createBasedService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "subscription",
-        createSubscriptionService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "file",
-        createFileService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "payment",
-        createPaymentService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "dns",
-        createDnsService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "branch",
-        createBranchService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "pullRequest",
-        createPullRequestService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "admin",
-        createAdminService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "screenshot",
-        createScreenshotService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "tracking",
-        createTrackingService({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "waitlist",
-        createWaitlistService({
+        "auth",
+        createAuthService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "metrics",
-        createMetricsService({
+        "socket",
+        createSocketService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "integration",
-        createIntegrationService({
+        "symstory",
+        createSymstoryService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "featureFlag",
-        createFeatureFlagService({
+        "ai",
+        createAIService({
           context: this._context,
           options: this._options
         })
@@ -180,33 +72,16 @@ class SDK {
     this._services.set(name, service);
   }
   _validateOptions(options) {
-    const onLocalhost = isLocalhost();
-    const hasGrafanaUrl = Boolean(environment.grafanaUrl);
     const defaults = {
       useNewServices: true,
       // Use new service implementations by default
-      apiUrl: environment.apiUrl,
+      baseUrl: environment.baseUrl,
       socketUrl: environment.socketUrl,
       timeout: 3e4,
       retryAttempts: 3,
-      debug: false,
-      tracking: {
-        // Force-disabled on localhost or when no Grafana URL is configured
-        enabled: onLocalhost ? false : hasGrafanaUrl ? environment.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) {
@@ -217,19 +92,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 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() {
@@ -258,65 +136,11 @@ 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;
-import {
-  createAuthService as createAuthService2,
-  createCollabService as createCollabService2,
-  createProjectService as createProjectService2,
-  createPlanService as createPlanService2,
-  createFileService as createFileService2,
-  createPaymentService as createPaymentService2,
-  createDnsService as createDnsService2,
-  createBranchService as createBranchService2,
-  createPullRequestService as createPullRequestService2,
-  createAdminService as createAdminService2,
-  createSubscriptionService as createSubscriptionService2,
-  createTrackingService as createTrackingService2,
-  createWaitlistService as createWaitlistService2,
-  createMetricsService as createMetricsService2,
-  createIntegrationService as createIntegrationService2,
-  createFeatureFlagService as createFeatureFlagService2
-} from "./services/index.js";
 import { default as default2 } from "./config/environment.js";
 export {
   SDK,
-  createAdminService2 as createAdminService,
-  createAuthService2 as createAuthService,
-  createBranchService2 as createBranchService,
-  createCollabService2 as createCollabService,
-  createDnsService2 as createDnsService,
-  createFeatureFlagService2 as createFeatureFlagService,
-  createFileService2 as createFileService,
-  createIntegrationService2 as createIntegrationService,
-  createMetricsService2 as createMetricsService,
-  createPaymentService2 as createPaymentService,
-  createPlanService2 as createPlanService,
-  createProjectService2 as createProjectService,
-  createPullRequestService2 as createPullRequestService,
-  createSubscriptionService2 as createSubscriptionService,
-  createTrackingService2 as createTrackingService,
-  createWaitlistService2 as createWaitlistService,
   index_default as default,
-  default2 as environment,
-  isLocalhost
+  default2 as environment
 };

package/dist/node/services/AIService.js

@@ -0,0 +1,136 @@
+import { BaseService } from "./BaseService.js";
+class AIService extends 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);
+  }
+}
+export {
+  AIService
+};