luxlabs 1.0.10 → 1.0.11

package/commands/ab-tests.js

@@ -1,25 +1,32 @@
 /**
  * A/B Tests Commands
  *
- * CLI commands for reading A/B test configurations.
+ * CLI commands for reading and managing A/B test configurations.
  * These are primarily used by Claude Code to understand what variants exist
  * and what they should do (via the descriptions).
  *
- * Commands:
+ * Read Commands:
  * - lux ab-tests list-tests [interface]              List all A/B tests
  * - lux ab-tests get-test <key> [interface]          Get details for a specific test
  * - lux ab-tests get-variant <key> <variant> [interface]  Get details for a specific variant
+ *
+ * Lifecycle Commands (called by agent after implementing changes):
+ * - lux ab-tests create-finished <test-id> --interface <id>   Sync new test to PostHog
+ * - lux ab-tests update-finished <test-id> --interface <id>   Sync updated test to PostHog
+ * - lux ab-tests delete-finished <test-id> --interface <id>   Remove test from PostHog
  */
 
 const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
+const ora = require('ora');
 
 /**
  * Show help for ab-tests commands
  */
 function showHelp() {
   console.log(chalk.cyan('\nLux A/B Tests Commands:\n'));
+  console.log(chalk.yellow('Read Commands:\n'));
   console.log(chalk.white('  lux ab-tests list-tests [interface]'));
   console.log(chalk.dim('    List all A/B tests for an interface'));
   console.log(chalk.dim('    Options: --json (JSON output)\n'));
@@ -29,6 +36,16 @@ function showHelp() {
   console.log(chalk.white('  lux ab-tests get-variant <test-key> <variant-key> [interface]'));
   console.log(chalk.dim('    Get details for a specific variant within a test'));
   console.log(chalk.dim('    Options: --json (JSON output)\n'));
+  console.log(chalk.yellow('Lifecycle Commands (called by agent after implementing changes):\n'));
+  console.log(chalk.white('  lux ab-tests create-finished <test-id> --interface <id>'));
+  console.log(chalk.dim('    Sync a new A/B test to PostHog after implementation'));
+  console.log(chalk.dim('    Updates status to "active"\n'));
+  console.log(chalk.white('  lux ab-tests update-finished <test-id> --interface <id>'));
+  console.log(chalk.dim('    Sync updated A/B test to PostHog after code changes'));
+  console.log(chalk.dim('    Updates status to "active"\n'));
+  console.log(chalk.white('  lux ab-tests delete-finished <test-id> --interface <id>'));
+  console.log(chalk.dim('    Remove A/B test from PostHog and database after code removal'));
+  console.log(chalk.dim('    Deletes test completely\n'));
 }
 
 /**
@@ -264,15 +281,15 @@ async function getTest(testKey, interfaceId, options) {
     }
   }
 
-  // Show implementation pattern
-  const nonControlVariants = test.variants.filter(v => v.key !== 'current' && v.key !== 'control');
-  if (nonControlVariants.length > 0) {
+  // Show implementation pattern - all variants are now UUID-keyed
+  if (test.variants.length > 0) {
     console.log(chalk.dim('\n   Implementation Pattern:'));
     console.log(chalk.gray(`   import { useFeatureFlagVariantKey } from 'posthog-js/react';`));
     console.log(chalk.gray(`   const variant = useFeatureFlagVariantKey('${test.key}');`));
-    for (const v of nonControlVariants) {
+    for (const v of test.variants) {
+      const letter = v.letter || 'A';
       const comment = v.description ? ` /* ${v.description} */` : '';
-      console.log(chalk.gray(`   if (variant === '${v.key}') {${comment} }`));
+      console.log(chalk.gray(`   if (variant === '${v.key}') { // Variant ${letter}${comment} }`));
     }
   }
 
@@ -347,19 +364,18 @@ async function getVariant(testKey, variantKey, interfaceId, options) {
     }
   }
 
-  // Show implementation hint
-  const isControl = variant.key === 'current' || variant.key === 'control';
-  if (!isControl) {
-    console.log(chalk.dim('\n   Implementation:'));
-    console.log(chalk.gray(`   import { useFeatureFlagVariantKey } from 'posthog-js/react';`));
-    console.log(chalk.gray(`   const variant = useFeatureFlagVariantKey('${test.key}');`));
-    console.log(chalk.gray(`   if (variant === '${variant.key}') {`));
-    if (variant.description) {
-      console.log(chalk.gray(`     // ${variant.description}`));
-    }
-    console.log(chalk.gray(`   }`));
-  } else {
-    console.log(chalk.dim('\n   Note: This is the control/baseline variant (default behavior).'));
+  // Show implementation hint - all variants now have UUID keys
+  const isFirstVariant = variant.letter === 'A';
+  console.log(chalk.dim('\n   Implementation:'));
+  console.log(chalk.gray(`   import { useFeatureFlagVariantKey } from 'posthog-js/react';`));
+  console.log(chalk.gray(`   const variant = useFeatureFlagVariantKey('${test.key}');`));
+  console.log(chalk.gray(`   if (variant === '${variant.key}') { // Variant ${variant.letter || 'A'}`));
+  if (variant.description) {
+    console.log(chalk.gray(`     // ${variant.description}`));
+  }
+  console.log(chalk.gray(`   }`));
+  if (isFirstVariant) {
+    console.log(chalk.dim('\n   Note: This is variant A (typically the baseline/control).'));
   }
 
   console.log();
@@ -369,12 +385,18 @@ async function getVariant(testKey, variantKey, interfaceId, options) {
  * Parse command options from args array
  */
 function parseOptions(args) {
-  const options = { json: false };
+  const options = { json: false, interface: null };
   const remaining = [];
 
-  for (const arg of args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
     if (arg === '--json') {
       options.json = true;
+    } else if (arg === '--interface' || arg === '-i') {
+      // Next arg is the interface ID
+      if (i + 1 < args.length) {
+        options.interface = args[++i];
+      }
     } else if (!arg.startsWith('-')) {
       remaining.push(arg);
     }
@@ -383,6 +405,234 @@ function parseOptions(args) {
   return { options, remaining };
 }
 
+/**
+ * Get credentials from config file
+ */
+function getCredentials() {
+  const os = require('os');
+  const configPath = path.join(os.homedir(), '.lux', 'config.json');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return {
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      projectId: config.projectId,
+      apiUrl: config.apiUrl || 'https://v2.uselux.ai'
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get interface ID from options or auto-detect
+ */
+function getInterfaceId(options) {
+  if (options.interface) {
+    return options.interface;
+  }
+
+  // Try to auto-detect from .lux.json in current interface repo
+  const luxConfigPath = path.join(process.cwd(), '.lux.json');
+  if (fs.existsSync(luxConfigPath)) {
+    try {
+      const luxConfig = JSON.parse(fs.readFileSync(luxConfigPath, 'utf-8'));
+      if (luxConfig.interfaceId) {
+        return luxConfig.interfaceId;
+      }
+    } catch (e) { /* ignore */ }
+  }
+
+  // Try to find from interfaces directory structure
+  const interfacesDir = path.join(process.cwd(), 'interfaces');
+  if (fs.existsSync(interfacesDir)) {
+    const entries = fs.readdirSync(interfacesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory());
+    if (dirs.length === 1) {
+      return dirs[0].name;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Call API endpoint for lifecycle operations
+ */
+async function callLifecycleApi(endpoint, testId, interfaceId, creds) {
+  const url = `${creds.apiUrl}/api/interfaces/${interfaceId}/ab-tests/${testId}/${endpoint}`;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${creds.apiKey}`,
+      'X-Org-Id': creds.orgId,
+      'X-Project-Id': creds.projectId,
+      'Content-Type': 'application/json'
+    }
+  });
+
+  const data = await response.json();
+
+  if (!response.ok) {
+    throw new Error(data.error || `API returned ${response.status}`);
+  }
+
+  return data;
+}
+
+/**
+ * Update local ab-tests.json status
+ */
+function updateLocalTestStatus(interfaceId, testId, status) {
+  const testsPath = getABTestsPath(interfaceId);
+  if (!testsPath || !fs.existsSync(testsPath)) {
+    return false;
+  }
+
+  try {
+    const tests = JSON.parse(fs.readFileSync(testsPath, 'utf-8'));
+    const testIndex = tests.findIndex(t => t.id === testId);
+    if (testIndex === -1) {
+      return false;
+    }
+
+    tests[testIndex].status = status;
+    tests[testIndex].updatedAt = Date.now();
+
+    fs.writeFileSync(testsPath, JSON.stringify(tests, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Remove test from local ab-tests.json
+ */
+function removeLocalTest(interfaceId, testId) {
+  const testsPath = getABTestsPath(interfaceId);
+  if (!testsPath || !fs.existsSync(testsPath)) {
+    return false;
+  }
+
+  try {
+    const tests = JSON.parse(fs.readFileSync(testsPath, 'utf-8'));
+    const testIndex = tests.findIndex(t => t.id === testId);
+    if (testIndex === -1) {
+      return false;
+    }
+
+    tests.splice(testIndex, 1);
+    fs.writeFileSync(testsPath, JSON.stringify(tests, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Create finished - sync new test to PostHog after agent implementation
+ */
+async function createFinished(testId, options) {
+  const spinner = ora('Syncing new A/B test to PostHog...').start();
+
+  try {
+    const creds = getCredentials();
+    if (!creds || !creds.apiKey) {
+      spinner.fail('Not authenticated. Run "lux login" first.');
+      return;
+    }
+
+    const interfaceId = getInterfaceId(options);
+    if (!interfaceId) {
+      spinner.fail('Could not determine interface ID. Use --interface <id> to specify.');
+      return;
+    }
+
+    // Call API to sync to PostHog and update DB
+    const result = await callLifecycleApi('create-finished', testId, interfaceId, creds);
+
+    // Update local file status
+    updateLocalTestStatus(interfaceId, testId, 'active');
+
+    spinner.succeed(`A/B test "${result.test?.name || testId}" synced to PostHog`);
+    console.log(chalk.dim(`  PostHog flag ID: ${result.posthogFlagId}`));
+    console.log(chalk.dim(`  Status: active`));
+  } catch (error) {
+    spinner.fail(`Failed to sync A/B test: ${error.message}`);
+  }
+}
+
+/**
+ * Update finished - sync updated test to PostHog after agent code changes
+ */
+async function updateFinished(testId, options) {
+  const spinner = ora('Syncing A/B test changes to PostHog...').start();
+
+  try {
+    const creds = getCredentials();
+    if (!creds || !creds.apiKey) {
+      spinner.fail('Not authenticated. Run "lux login" first.');
+      return;
+    }
+
+    const interfaceId = getInterfaceId(options);
+    if (!interfaceId) {
+      spinner.fail('Could not determine interface ID. Use --interface <id> to specify.');
+      return;
+    }
+
+    // Call API to sync to PostHog and update DB
+    const result = await callLifecycleApi('update-finished', testId, interfaceId, creds);
+
+    // Update local file status
+    updateLocalTestStatus(interfaceId, testId, 'active');
+
+    spinner.succeed(`A/B test "${result.test?.name || testId}" updated and synced`);
+    console.log(chalk.dim(`  Status: active`));
+  } catch (error) {
+    spinner.fail(`Failed to sync A/B test: ${error.message}`);
+  }
+}
+
+/**
+ * Delete finished - remove test from PostHog and DB after agent removes code
+ */
+async function deleteFinished(testId, options) {
+  const spinner = ora('Removing A/B test from PostHog...').start();
+
+  try {
+    const creds = getCredentials();
+    if (!creds || !creds.apiKey) {
+      spinner.fail('Not authenticated. Run "lux login" first.');
+      return;
+    }
+
+    const interfaceId = getInterfaceId(options);
+    if (!interfaceId) {
+      spinner.fail('Could not determine interface ID. Use --interface <id> to specify.');
+      return;
+    }
+
+    // Call API to delete from PostHog and DB
+    const result = await callLifecycleApi('delete-finished', testId, interfaceId, creds);
+
+    // Remove from local file
+    removeLocalTest(interfaceId, testId);
+
+    spinner.succeed(`A/B test "${result.deletedTest?.name || testId}" deleted`);
+    console.log(chalk.dim(`  Removed from PostHog, database, and local storage`));
+  } catch (error) {
+    spinner.fail(`Failed to delete A/B test: ${error.message}`);
+  }
+}
+
 /**
  * Handle ab-tests commands
  */
@@ -425,6 +675,32 @@ async function handleABTests(args) {
       await getVariant(remaining[0], remaining[1], remaining[2], options);
       break;
 
+    case 'create-finished':
+      if (!remaining[0]) {
+        console.log(chalk.red('Missing test ID. Usage: lux ab-tests create-finished <test-id> --interface <id>'));
+        return;
+      }
+      await createFinished(remaining[0], options);
+      break;
+
+    case 'update-finished':
+      if (!remaining[0]) {
+        console.log(chalk.red('Missing test ID. Usage: lux ab-tests update-finished <test-id> --interface <id>'));
+        return;
+      }
+      await updateFinished(remaining[0], options);
+      break;
+
+    case 'delete-finished':
+    case 'delete':
+    case 'rm':
+      if (!remaining[0]) {
+        console.log(chalk.red('Missing test ID. Usage: lux ab-tests delete-finished <test-id> --interface <id>'));
+        return;
+      }
+      await deleteFinished(remaining[0], options);
+      break;
+
     default:
       console.log(chalk.red(`Unknown subcommand: ${subcommand}`));
       showHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luxlabs",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "CLI tool for Lux - Upload and deploy interfaces from your terminal",
   "author": "Jason Henkel <jason@uselux.ai>",
   "license": "SEE LICENSE IN LICENSE",

package/templates/interface-boilerplate/components/providers/posthog-provider.tsx

@@ -74,6 +74,9 @@ export function PostHogProvider({ children }: { children: React.ReactNode }) {
       // Override feature flags for Lux Studio preview
       posthog.featureFlags.override(flagOverrides)
       console.log('[PostHog] Applied Lux Studio flag overrides:', flagOverrides)
+
+      // Force reload to make React hooks aware of the change
+      posthog.reloadFeatureFlags()
     } else {
       // Clear any previous overrides when not in preview mode
       posthog.featureFlags.override(false)