@shohojdhara/atomix 0.4.7 → 0.4.9

package/scripts/cli/internal/tokens/engine.js

@@ -0,0 +1,122 @@
+/**
+ * Atomix CLI Universal Token Engine
+ * Manages token providers and bi-directional sync
+ */
+
+import { logger } from '../../utils/logger.js';
+import { configLoader } from '../config-loader.js';
+import { hookManager } from '../hooks.js';
+
+export class TokenEngine {
+  constructor() {
+    this.providers = new Map();
+  }
+
+  /**
+   * Initializes the engine with providers from the config
+   */
+  async initialize() {
+    const config = configLoader.getConfig();
+    const tokenEngineConfig = config.tokenEngine || {};
+    const providers = tokenEngineConfig.providers || {};
+
+    for (const [name, providerConfig] of Object.entries(providers)) {
+      try {
+        const provider = await this._instantiateProvider(providerConfig);
+        if (provider) {
+          this.providers.set(name, provider);
+          logger.debug(`Initialized token provider: ${name} (${providerConfig.type})`);
+        }
+      } catch (error) {
+        logger.error(`Failed to initialize token provider ${name}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Instantiates a provider based on its type
+   * @private
+   */
+  async _instantiateProvider(providerConfig) {
+    const { type, options } = providerConfig;
+
+    switch (type) {
+      case 'figma': {
+        const { FigmaProvider } = await import('./providers/figma.js');
+        return new FigmaProvider(options);
+      }
+      case 'style-dictionary': {
+        const { StyleDictionaryProvider } = await import('./providers/style-dictionary.js');
+        return new StyleDictionaryProvider(options);
+      }
+      case 'w3c': {
+        const { W3CProvider } = await import('./providers/w3c.js');
+        return new W3CProvider(options);
+      }
+      default:
+        logger.warn(`Unknown token provider type: ${type}`);
+        return null;
+    }
+  }
+
+  /**
+   * Returns the list of configured provider names (for help and prompts)
+   * @returns {string[]}
+   */
+  getProviderNames() {
+    return [...this.providers.keys()];
+  }
+
+  /**
+   * Pulls tokens from a specific provider
+   * @param {string} providerName - Name of the provider to pull from
+   */
+  async pull(providerName) {
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Token provider not found: ${providerName}`);
+    }
+
+    logger.info(`Pulling tokens from ${providerName}...`);
+    
+    // Lifecycle hook
+    const initialData = await hookManager.trigger('prePullTokens', { providerName });
+
+    const tokens = await provider.pull();
+    
+    // Lifecycle hook
+    const finalTokens = await hookManager.trigger('postPullTokens', tokens);
+
+    logger.debug(`Successfully pulled tokens from ${providerName}`);
+    return finalTokens;
+  }
+
+  /**
+   * Pushes tokens back to a provider (Experimental)
+   * @param {string} providerName - Name of the provider to push to
+   * @param {Object} tokens - The tokens to push
+   */
+  async push(providerName, tokens) {
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`Token provider not found: ${providerName}`);
+    }
+
+    logger.info(`Pushing tokens to ${providerName}...`);
+
+    // Lifecycle hook
+    const preparedTokens = await hookManager.trigger('prePushTokens', tokens);
+
+    const success = await provider.push(preparedTokens);
+
+    if (success) {
+      logger.info(`Successfully pushed tokens to ${providerName}`);
+    } else {
+      logger.error(`Failed to push tokens to ${providerName}`);
+    }
+
+    return success;
+  }
+}
+
+export const tokenEngine = new TokenEngine();

package/scripts/cli/internal/tokens/provider.js

@@ -0,0 +1,34 @@
+/**
+ * Atomix CLI Token Provider Base Class
+ */
+
+export class TokenProvider {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Fetches tokens from the source
+   * @returns {Promise<Object>} - The fetched tokens
+   */
+  async pull() {
+    throw new Error('Provider.pull() not implemented');
+  }
+
+  /**
+   * Pushes local changes to the source (Experimental)
+   * @param {Object} tokens - The tokens to push
+   * @returns {Promise<boolean>} - Success status
+   */
+  async push(tokens) {
+    throw new Error('Provider.push() not implemented');
+  }
+
+  /**
+   * Validates the provider configuration
+   * @returns {Object} - { isValid: boolean, error?: string }
+   */
+  validate() {
+    return { isValid: true };
+  }
+}

package/scripts/cli/internal/tokens/providers/figma.js

@@ -0,0 +1,50 @@
+/**
+ * Atomix CLI Figma Token Provider
+ */
+
+import { TokenProvider } from '../provider.js';
+import { logger } from '../../../utils/logger.js';
+
+export class FigmaProvider extends TokenProvider {
+  constructor(options = {}) {
+    super(options);
+    this.apiKey = options.apiKey || process.env.FIGMA_API_KEY;
+    this.fileId = options.fileId;
+  }
+
+  /**
+   * Fetches tokens from Figma
+   */
+  async pull() {
+    if (!this.apiKey || !this.fileId) {
+      throw new Error('Figma provider requires an API key and file ID.');
+    }
+
+    logger.debug(`Fetching Figma file: ${this.fileId}`);
+    
+    // In a real implementation, we'd use the Figma API here.
+    // For now, return a placeholder to demonstrate the architecture.
+    return {
+      source: 'figma',
+      fileId: this.fileId,
+      tokens: {
+        colors: {
+          primary: '#3b82f6',
+          secondary: '#10b981'
+        },
+        spacing: {
+          '1': '0.25rem',
+          '2': '0.5rem'
+        }
+      }
+    };
+  }
+
+  /**
+   * Pushes tokens to Figma (Experimental)
+   */
+  async push(tokens) {
+    logger.warn('Pushing tokens to Figma is currently experimental and not fully implemented.');
+    return false;
+  }
+}

package/scripts/cli/internal/tokens/providers/style-dictionary.js

@@ -0,0 +1,48 @@
+/**
+ * Atomix CLI Style Dictionary Token Provider
+ */
+
+import { TokenProvider } from '../provider.js';
+import { logger } from '../../../utils/logger.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export class StyleDictionaryProvider extends TokenProvider {
+  constructor(options = {}) {
+    super(options);
+    this.configPath = options.configPath || './style-dictionary.config.js';
+  }
+
+  /**
+   * Fetches tokens from Style Dictionary
+   */
+  async pull() {
+    const fullPath = join(process.cwd(), this.configPath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`Style Dictionary config not found: ${this.configPath}`);
+    }
+
+    logger.debug(`Loading Style Dictionary config: ${this.configPath}`);
+    
+    // In a real implementation, we'd use Style Dictionary here.
+    // For now, return a placeholder to demonstrate the architecture.
+    return {
+      source: 'style-dictionary',
+      config: this.configPath,
+      tokens: {
+        colors: {
+          brand: '#3b82f6',
+          accent: '#10b981'
+        }
+      }
+    };
+  }
+
+  /**
+   * Pushes tokens back (Not supported for Style Dictionary)
+   */
+  async push(tokens) {
+    logger.warn('Style Dictionary provider does not support pushing tokens.');
+    return false;
+  }
+}

package/scripts/cli/internal/tokens/providers/w3c.js

@@ -0,0 +1,48 @@
+/**
+ * Atomix CLI W3C Token Provider
+ */
+
+import { TokenProvider } from '../provider.js';
+import { logger } from '../../../utils/logger.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export class W3CProvider extends TokenProvider {
+  constructor(options = {}) {
+    super(options);
+    this.tokenPath = options.tokenPath || './tokens.json';
+  }
+
+  /**
+   * Fetches tokens from a W3C Design Tokens file
+   */
+  async pull() {
+    const fullPath = join(process.cwd(), this.tokenPath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`W3C tokens file not found: ${this.tokenPath}`);
+    }
+
+    logger.debug(`Loading W3C tokens file: ${this.tokenPath}`);
+    
+    try {
+      const content = readFileSync(fullPath, 'utf8');
+      const tokens = JSON.parse(content);
+      
+      return {
+        source: 'w3c',
+        tokenPath: this.tokenPath,
+        tokens
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse W3C tokens file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Pushes tokens back (Experimental)
+   */
+  async push(tokens) {
+    logger.warn('W3C provider does not support pushing tokens.');
+    return false;
+  }
+}