dank-ai 1.0.19 → 1.0.21

package/bin/dank

@@ -14,12 +14,17 @@ const { initCommand } = require('../lib/cli/init');
 const { statusCommand } = require('../lib/cli/status');
 const { stopCommand } = require('../lib/cli/stop');
 const { logsCommand } = require('../lib/cli/logs');
+const analytics = require('../lib/analytics');
 
 program
   .name('dank')
   .description('🚀 Dank Agent Service - Docker-based AI agent orchestration')
   .version(pkg.version);
 
+// Track CLI usage and install
+analytics.trackCLIUsage();
+analytics.trackInstall();
+
 // Run command - main orchestration command
 program
   .command('run')

package/lib/analytics.js

@@ -0,0 +1,241 @@
+const https = require('https');
+const crypto = require('crypto');
+
+class Analytics {
+  constructor() {
+    this.enabled = true;
+    this.projectToken = process.env.MIXPANEL_PROJECT_TOKEN || '2ab09eb7ea93ec0f288758866280bec6'; // Use env var or fallback
+    this.apiUrl = 'https://api.mixpanel.com/track';
+    this.userId = this.generateAnonymousId();
+    this.sessionId = this.generateSessionId();
+    this.installDate = this.getInstallDate();
+  }
+
+  generateAnonymousId() {
+    // Generate a consistent anonymous ID based on machine characteristics
+    const os = require('os');
+    const machineId = os.hostname() + os.platform() + os.arch();
+    return crypto.createHash('sha256').update(machineId).digest('hex').substring(0, 16);
+  }
+
+  generateSessionId() {
+    return crypto.randomBytes(16).toString('hex');
+  }
+
+  getInstallDate() {
+    // Try to get install date from package.json or use current date
+    try {
+      const pkg = require('../package.json');
+      return new Date(pkg.date || Date.now()).toISOString().split('T')[0];
+    } catch (error) {
+      return new Date().toISOString().split('T')[0];
+    }
+  }
+
+  async track(event, properties = {}) {
+    if (!this.enabled) return;
+
+    const payload = {
+      event,
+      properties: {
+        ...properties,
+        distinct_id: this.userId,
+        session_id: this.sessionId,
+        platform: process.platform,
+        arch: process.arch,
+        node_version: process.version,
+        version: require('../package.json').version,
+        time: new Date().toISOString()
+      }
+    };
+
+    // Send asynchronously without blocking
+    this.sendEvent(payload).catch(() => {
+      // Fail silently - don't break user experience
+    });
+  }
+
+  async sendEvent(payload) {
+    const data = JSON.stringify(payload);
+    
+    const options = {
+      hostname: 'api.mixpanel.com',
+      port: 443,
+      path: '/track',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': data.length,
+        'User-Agent': 'dank-cli'
+      }
+    };
+
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        resolve();
+      });
+      req.on('error', reject);
+      req.write(data);
+      req.end();
+    });
+  }
+
+  // ===== INSTALL & ACTIVATION TRACKING =====
+  
+  async trackInstall() {
+    await this.track('Dank Installed', {
+      install_date: this.installDate,
+      version: require('../package.json').version,
+      platform: process.platform,
+      arch: process.arch
+    });
+  }
+
+  async trackDailyActive() {
+    await this.track('Dank Daily Active', {
+      version: require('../package.json').version,
+      platform: process.platform
+    });
+  }
+
+  async trackMonthlyActive() {
+    await this.track('Dank Monthly Active', {
+      version: require('../package.json').version,
+      platform: process.platform
+    });
+  }
+
+  // ===== FUNNEL TRACKING =====
+  
+  async trackFunnelStep(step, properties = {}) {
+    await this.track('Dank Funnel Step', {
+      funnel_step: step,
+      ...properties
+    });
+  }
+
+  async trackProjectCreated(projectName, template = 'basic') {
+    await this.track('Dank Project Created', {
+      project_name: projectName,
+      template: template,
+      funnel_step: 'project_created'
+    });
+  }
+
+  async trackProjectRun(projectName, agentCount) {
+    await this.track('Dank Project Run', {
+      project_name: projectName,
+      agent_count: agentCount,
+      funnel_step: 'project_run'
+    });
+  }
+
+  async trackFirstAgentRun(projectName) {
+    await this.track('Dank First Agent Run', {
+      project_name: projectName,
+      funnel_step: 'first_agent_run'
+    });
+  }
+
+  // ===== AGENT TRACKING =====
+  
+  async trackAgentStart(agentName, success = true, properties = {}) {
+    await this.track('Dank Agent Started', {
+      agent_name: agentName,
+      success: success,
+      ...properties
+    });
+  }
+
+  async trackAgentStop(agentName, success = true, properties = {}) {
+    await this.track('Dank Agent Stopped', {
+      agent_name: agentName,
+      success: success,
+      ...properties
+    });
+  }
+
+  async trackAgentBuild(agentName, success = true, buildTime = null) {
+    await this.track('Dank Agent Built', {
+      agent_name: agentName,
+      success: success,
+      build_time: buildTime,
+      ...properties
+    });
+  }
+
+  async trackAgentError(agentName, error, properties = {}) {
+    await this.track('Dank Agent Error', {
+      agent_name: agentName,
+      error_type: error.constructor.name,
+      error_message: error.message,
+      ...properties
+    });
+  }
+
+  // ===== COMMAND TRACKING =====
+  
+  async trackCommand(command, success = true, properties = {}) {
+    await this.track('Dank Command Executed', {
+      command: command,
+      success: success,
+      ...properties
+    });
+  }
+
+  async trackCLIUsage() {
+    await this.track('Dank CLI Used', {
+      version: require('../package.json').version,
+      platform: process.platform
+    });
+  }
+
+  // ===== DOCKER TRACKING =====
+  
+  async trackDockerInstall(success = true, platform = process.platform) {
+    await this.track('Dank Docker Install', {
+      success: success,
+      platform: platform
+    });
+  }
+
+  async trackDockerOperation(operation, success = true, properties = {}) {
+    await this.track('Dank Docker Operation', {
+      operation: operation,
+      success: success,
+      ...properties
+    });
+  }
+
+  // ===== FEATURE USAGE TRACKING =====
+  
+  async trackFeatureUsed(feature, properties = {}) {
+    await this.track('Dank Feature Used', {
+      feature: feature,
+      ...properties
+    });
+  }
+
+  async trackProductionBuild(agentName, registry, namespace, tag) {
+    await this.track('Dank Production Build', {
+      agent_name: agentName,
+      registry: registry,
+      namespace: namespace,
+      tag: tag,
+      funnel_step: 'production_build'
+    });
+  }
+
+  // ===== ERROR TRACKING =====
+  
+  async trackError(error, context = {}) {
+    await this.track('Dank Error', {
+      error_type: error.constructor.name,
+      error_message: error.message,
+      error_stack: error.stack,
+      context: context
+    });
+  }
+}
+
+module.exports = new Analytics();

package/lib/cli/init.js

@@ -6,8 +6,16 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const { DankProject } = require('../project');
+const analytics = require('../analytics');
 
 async function initCommand(projectName, options) {
+  // Track project creation and funnel step
+  await analytics.trackProjectCreated(projectName, options.template || 'basic');
+  await analytics.trackFunnelStep('project_created', {
+    project_name: projectName,
+    template: options.template || 'basic'
+  });
+
   let name = projectName;
   let npmProjectName = projectName;
   

package/lib/cli/production-build.js

@@ -6,8 +6,15 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const { DockerManager } = require('../docker/manager');
+const analytics = require('../analytics');
 
 async function productionBuildCommand(options) {
+  // Track production build command
+  await analytics.trackCommand('build:prod', true, {
+    push: options.push || false,
+    force: options.force || false
+  });
+
   try {
     console.log(chalk.yellow('🏗️  Building production Docker images...\n'));
 
@@ -44,6 +51,14 @@ async function productionBuildCommand(options) {
         
         const result = await dockerManager.buildProductionImage(agent, buildOptions);
 
+        // Track production build success
+        await analytics.trackProductionBuild(
+          agent.name, 
+          buildOptions.registry, 
+          buildOptions.namespace, 
+          buildOptions.tag
+        );
+
         buildResults.push({
           agent: agent.name,
           imageName: result.imageName,

package/lib/cli/run.js

@@ -7,10 +7,15 @@ const path = require('path');
 const chalk = require('chalk');
 const { DockerManager } = require('../docker/manager');
 const { DankProject } = require('../project');
+const analytics = require('../analytics');
 
 async function runCommand(options) {
   console.log(chalk.yellow('🚀 Starting Dank agents...\\n'));
 
+  // Track daily active user and CLI usage
+  await analytics.trackDailyActive();
+  await analytics.trackCLIUsage();
+
   try {
     // Load configuration
     const configPath = path.resolve(options.config);
@@ -29,6 +34,9 @@ async function runCommand(options) {
     }
 
     console.log(chalk.green(`✅ Found ${config.agents.length} agents`));
+    
+    // Track project run
+    await analytics.trackProjectRun('unknown', config.agents.length);
 
     // Initialize Docker manager
     console.log(chalk.blue('🐳 Initializing Docker...'));

package/lib/docker/manager.js

@@ -18,6 +18,7 @@ const { spawn, exec } = require("child_process");
 const { promisify } = require("util");
 const { DOCKER_CONFIG } = require("../constants");
 const { AgentConfig } = require("../config");
+const analytics = require("../analytics");
 
 const execAsync = promisify(exec);
 
@@ -261,6 +262,9 @@ class DockerManager {
 
     this.logger.info(`Installing Docker for ${platform}...`);
 
+    // Track Docker installation attempt
+    await analytics.trackDockerInstall(true, platform);
+
     try {
       if (platform === "darwin") {
         await this.installDockerMacOS();
@@ -273,7 +277,14 @@ class DockerManager {
       }
 
       this.logger.info("Docker installation completed");
+      
+      // Track successful Docker installation
+      await analytics.trackDockerInstall(true, platform);
     } catch (error) {
+      // Track failed Docker installation
+      await analytics.trackDockerInstall(false, platform);
+      await analytics.trackError(error, { context: 'docker_install', platform });
+      
       throw new Error(`Failed to install Docker: ${error.message}`);
     }
   }
@@ -1263,6 +1274,12 @@ class DockerManager {
    * Start agent container
    */
   async startAgent(agent, options = {}) {
+    // Track agent start attempt
+    await analytics.trackAgentStart(agent.name, true, {
+      rebuild: options.rebuild || false,
+      has_docker_config: !!agent.config.docker
+    });
+
     // Finalize agent configuration (auto-detect features)
     agent.finalize();
 
@@ -1338,8 +1355,22 @@ class DockerManager {
         )})`
       );
 
+      // Track successful agent start
+      await analytics.trackAgentStart(agent.name, true, {
+        success: true,
+        container_id: container.id.substring(0, 12)
+      });
+
       return container;
     } catch (error) {
+      // Track failed agent start
+      await analytics.trackAgentStart(agent.name, false, {
+        error: error.message
+      });
+      await analytics.trackAgentError(agent.name, error, {
+        context: 'agent_start'
+      });
+      
       agent.status = "error";
       throw new Error(`Failed to start agent ${agent.name}: ${error.message}`);
     }
@@ -1349,6 +1380,11 @@ class DockerManager {
    * Stop agent container
    */
   async stopAgent(agentName, options = {}) {
+    // Track agent stop attempt
+    await analytics.trackAgentStop(agentName, true, {
+      force: options.force || false
+    });
+
     const containerInfo = this.containers.get(agentName);
     if (!containerInfo) {
       throw new Error(`Agent ${agentName} not found or not running`);
@@ -1372,7 +1408,20 @@ class DockerManager {
       agent.containerId = null;
 
       this.logger.info(`Agent ${agentName} stopped successfully`);
+      
+      // Track successful agent stop
+      await analytics.trackAgentStop(agentName, true, {
+        success: true
+      });
     } catch (error) {
+      // Track failed agent stop
+      await analytics.trackAgentStop(agentName, false, {
+        error: error.message
+      });
+      await analytics.trackAgentError(agentName, error, {
+        context: 'agent_stop'
+      });
+      
       throw new Error(`Failed to stop agent ${agentName}: ${error.message}`);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dank-ai",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Dank Agent Service - Docker-based AI agent orchestration platform",
   "main": "lib/index.js",
   "exports": {