dank-ai 1.0.0

package/lib/cli/clean.js

@@ -0,0 +1,30 @@
+/**
+ * CLI Clean Command - Clean up Docker resources
+ */
+
+const chalk = require('chalk');
+const { DockerManager } = require('../docker/manager');
+
+async function cleanCommand(options) {
+  console.log(chalk.yellow('🧹 Cleaning up Docker resources...\\n'));
+
+  try {
+    const dockerManager = new DockerManager();
+    await dockerManager.initialize();
+
+    await dockerManager.cleanup({
+      all: options.all,
+      containers: options.containers || options.all,
+      images: options.images || options.all,
+      buildContexts: options.buildContexts || options.all
+    });
+
+    console.log(chalk.green('\\n✅ Cleanup completed successfully!'));
+
+  } catch (error) {
+    console.error(chalk.red('❌ Cleanup failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { cleanCommand };

package/lib/cli/init.js

@@ -0,0 +1,38 @@
+/**
+ * CLI Init Command - Initialize new Dank project
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { DankProject } = require('../project');
+
+async function initCommand(projectName, options) {
+  const name = projectName || path.basename(process.cwd());
+  
+  console.log(chalk.yellow(`🚀 Initializing Dank project: ${name}\\n`));
+
+  try {
+    // Create project instance
+    const project = new DankProject(name, {
+      template: options.template,
+      force: options.force
+    });
+
+    // Initialize project structure
+    await project.init();
+
+    console.log(chalk.green('\\n✅ Project initialized successfully!'));
+    console.log(chalk.cyan('\\nNext steps:'));
+    console.log(chalk.gray('  1. Set your API keys in environment variables'));
+    console.log(chalk.gray('  2. Edit dank.config.js to configure your agents'));
+    console.log(chalk.gray('  3. Run "dank run" to start your agents'));
+    console.log(chalk.gray('\\nFor more information, visit: https://github.com/your-org/dank'));
+
+  } catch (error) {
+    console.error(chalk.red('❌ Initialization failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { initCommand };

package/lib/cli/logs.js

@@ -0,0 +1,122 @@
+/**
+ * CLI Logs Command - View agent logs
+ */
+
+const chalk = require('chalk');
+const { DockerManager } = require('../docker/manager');
+
+async function logsCommand(agentName, options) {
+  try {
+    const dockerManager = new DockerManager();
+    await dockerManager.initialize();
+
+    if (agentName) {
+      await showAgentLogs(dockerManager, agentName, options);
+    } else {
+      await showAllLogs(dockerManager, options);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('❌ Logs failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function showAgentLogs(dockerManager, agentName, options) {
+  console.log(chalk.yellow(`📋 Logs for agent: ${agentName}\\n`));
+
+  try {
+    const logStream = await dockerManager.getAgentLogs(agentName, {
+      follow: options.follow,
+      tail: parseInt(options.tail) || 100,
+      since: options.since
+    });
+
+    logStream.on('data', (chunk) => {
+      // Docker log format includes 8-byte header, remove it
+      const logLine = chunk.toString('utf8').substring(8);
+      
+      // Color code log levels
+      const coloredLine = logLine
+        .replace(/\\[ERROR\\]/g, chalk.red('[ERROR]'))
+        .replace(/\\[WARN\\]/g, chalk.yellow('[WARN]'))
+        .replace(/\\[INFO\\]/g, chalk.blue('[INFO]'))
+        .replace(/\\[DEBUG\\]/g, chalk.gray('[DEBUG]'));
+      
+      process.stdout.write(coloredLine);
+    });
+
+    logStream.on('end', () => {
+      if (!options.follow) {
+        console.log(chalk.gray('\\n--- End of logs ---'));
+      }
+    });
+
+    if (options.follow) {
+      console.log(chalk.gray('Following logs (Ctrl+C to stop)...'));
+      
+      process.on('SIGINT', () => {
+        console.log(chalk.yellow('\\n👋 Stopped following logs'));
+        process.exit(0);
+      });
+    }
+
+  } catch (error) {
+    throw new Error(`Failed to get logs for ${agentName}: ${error.message}`);
+  }
+}
+
+async function showAllLogs(dockerManager, options) {
+  console.log(chalk.yellow('📋 Logs from all agents\\n'));
+
+  try {
+    const containers = await dockerManager.docker.listContainers({
+      all: true,
+      filters: { name: ['dank-'] }
+    });
+
+    if (containers.length === 0) {
+      console.log(chalk.gray('No agents found.'));
+      return;
+    }
+
+    for (const containerInfo of containers) {
+      const agentName = containerInfo.Names[0].replace('/dank-', '').split('-')[0];
+      
+      console.log(chalk.cyan(`\\n=== ${agentName} ===`));
+      
+      try {
+        const logStream = await dockerManager.getAgentLogs(agentName, {
+          follow: false,
+          tail: parseInt(options.tail) || 50
+        });
+
+        logStream.on('data', (chunk) => {
+          const logLine = chunk.toString('utf8').substring(8);
+          const coloredLine = logLine
+            .replace(/\\[ERROR\\]/g, chalk.red('[ERROR]'))
+            .replace(/\\[WARN\\]/g, chalk.yellow('[WARN]'))
+            .replace(/\\[INFO\\]/g, chalk.blue('[INFO]'))
+            .replace(/\\[DEBUG\\]/g, chalk.gray('[DEBUG]'));
+          
+          process.stdout.write(`[${agentName}] ${coloredLine}`);
+        });
+
+        // Wait for logs to finish
+        await new Promise((resolve) => {
+          logStream.on('end', resolve);
+        });
+
+      } catch (error) {
+        console.log(chalk.red(`Failed to get logs for ${agentName}: ${error.message}`));
+      }
+    }
+
+    console.log(chalk.gray('\\n--- End of all logs ---'));
+
+  } catch (error) {
+    throw new Error(`Failed to get all logs: ${error.message}`);
+  }
+}
+
+module.exports = { logsCommand };

package/lib/cli/run.js

@@ -0,0 +1,176 @@
+/**
+ * CLI Run Command - Start all defined agents
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { DockerManager } = require('../docker/manager');
+const { DankProject } = require('../project');
+
+async function runCommand(options) {
+  console.log(chalk.yellow('🚀 Starting Dank agents...\\n'));
+
+  try {
+    // Load configuration
+    const configPath = path.resolve(options.config);
+    if (!(await fs.pathExists(configPath))) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+
+    console.log(chalk.blue('📋 Loading configuration...'));
+    
+    // Clear require cache to get fresh config
+    delete require.cache[require.resolve(configPath)];
+    const config = require(configPath);
+    
+    if (!config.agents || !Array.isArray(config.agents)) {
+      throw new Error('No agents defined in configuration');
+    }
+
+    console.log(chalk.green(`✅ Found ${config.agents.length} agents`));
+
+    // Initialize Docker manager
+    console.log(chalk.blue('🐳 Initializing Docker...'));
+    const dockerManager = new DockerManager();
+    await dockerManager.initialize();
+
+    // Clean up existing containers from previous runs
+    console.log(chalk.blue('🧹 Cleaning up existing containers...'));
+    await dockerManager.cleanupExistingContainers(config.agents);
+
+    // Pull base image if needed
+    if (options.pull) {
+      console.log(chalk.blue('📥 Pulling base image...'));
+      await dockerManager.pullBaseImage();
+    }
+
+    // Start agents
+    console.log(chalk.blue('\\n🎯 Starting agents...'));
+    
+    const parallel = parseInt(options.parallel) || 3;
+    const agentBatches = chunkArray(config.agents, parallel);
+    
+    const results = [];
+    
+    for (const batch of agentBatches) {
+      const batchPromises = batch.map(async (agent) => {
+        try {
+          console.log(chalk.gray(`  Starting ${agent.name}...`));
+          
+          const container = await dockerManager.startAgent(agent, {
+            rebuild: !options.noBuild  // Rebuild by default unless --no-build is specified
+          });
+          
+          console.log(chalk.green(`  ✅ ${agent.name} started (${container.id.substring(0, 12)})`));
+          
+          return { agent: agent.name, status: 'started', containerId: container.id };
+          
+        } catch (error) {
+          console.log(chalk.red(`  ❌ ${agent.name} failed: ${error.message}`));
+          return { agent: agent.name, status: 'failed', error: error.message };
+        }
+      });
+      
+      const batchResults = await Promise.allSettled(batchPromises);
+      results.push(...batchResults.map(r => r.value || r.reason));
+    }
+
+    // Summary
+    console.log(chalk.yellow('\\n📊 Summary:'));
+    const started = results.filter(r => r.status === 'started').length;
+    const failed = results.filter(r => r.status === 'failed').length;
+    
+    console.log(chalk.green(`  ✅ Started: ${started}`));
+    if (failed > 0) {
+      console.log(chalk.red(`  ❌ Failed: ${failed}`));
+    }
+
+    if (options.detached) {
+      console.log(chalk.cyan('\\n🔧 Agents running in detached mode'));
+      console.log(chalk.gray('Use "dank status" to check agent status'));
+      console.log(chalk.gray('Use "dank logs <agent>" to view logs'));
+    } else {
+      console.log(chalk.cyan('\\n👀 Monitoring agents (Ctrl+C to stop)...'));
+      
+      // Monitor agents
+      await monitorAgents(dockerManager, config.agents);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('❌ Run failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Monitor running agents
+ */
+async function monitorAgents(dockerManager, agents) {
+  const monitorInterval = setInterval(async () => {
+    try {
+      console.log(chalk.gray('\\n--- Agent Status ---'));
+      
+      for (const agent of agents) {
+        const status = await dockerManager.getAgentStatus(agent.name);
+        
+        const statusColor = status.status === 'running' ? chalk.green : 
+                           status.status === 'stopped' ? chalk.yellow : chalk.red;
+        
+        const uptime = status.uptime ? formatUptime(status.uptime) : 'N/A';
+        
+        console.log(`${statusColor('●')} ${agent.name}: ${status.status} (${uptime})`);
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('Monitor error:'), error.message);
+    }
+  }, 10000); // Check every 10 seconds
+
+  // Handle Ctrl+C
+  process.on('SIGINT', async () => {
+    console.log(chalk.yellow('\\n🛑 Stopping agents...'));
+    clearInterval(monitorInterval);
+    
+    try {
+      for (const agent of agents) {
+        await dockerManager.stopAgent(agent.name);
+      }
+      console.log(chalk.green('✅ All agents stopped'));
+    } catch (error) {
+      console.error(chalk.red('❌ Error stopping agents:'), error.message);
+    }
+    
+    process.exit(0);
+  });
+}
+
+/**
+ * Chunk array into smaller arrays
+ */
+function chunkArray(array, chunkSize) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+
+/**
+ * Format uptime in human readable format
+ */
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+module.exports = { runCommand };

package/lib/cli/status.js

@@ -0,0 +1,125 @@
+/**
+ * CLI Status Command - Show agent status
+ */
+
+const chalk = require('chalk');
+const { DockerManager } = require('../docker/manager');
+
+async function statusCommand(options) {
+  try {
+    const dockerManager = new DockerManager();
+    await dockerManager.initialize();
+
+    if (options.watch) {
+      await watchStatus(dockerManager, options);
+    } else {
+      await showStatus(dockerManager, options);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('❌ Status check failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function showStatus(dockerManager, options) {
+  console.log(chalk.yellow('📊 Agent Status\\n'));
+
+  try {
+    // Get all Dank containers
+    const containers = await dockerManager.docker.listContainers({
+      all: true,
+      filters: { name: ['dank-'] }
+    });
+
+    if (containers.length === 0) {
+      console.log(chalk.gray('No agents found. Run "dank run" to start agents.'));
+      return;
+    }
+
+    const statuses = [];
+
+    for (const containerInfo of containers) {
+      const container = dockerManager.docker.getContainer(containerInfo.Id);
+      const data = await container.inspect();
+      
+      const agentName = containerInfo.Names[0].replace('/dank-', '').split('-')[0];
+      const status = {
+        name: agentName,
+        id: containerInfo.Id.substring(0, 12),
+        status: data.State.Running ? 'running' : 'stopped',
+        uptime: data.State.Running ? Date.now() - new Date(data.State.StartedAt).getTime() : 0,
+        restarts: data.RestartCount,
+        health: data.State.Health?.Status || 'unknown',
+        memory: data.HostConfig.Memory,
+        cpu: data.HostConfig.CpuQuota / 1000
+      };
+
+      statuses.push(status);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(statuses, null, 2));
+      return;
+    }
+
+    // Display status table
+    console.log(chalk.bold('NAME\\t\\tSTATUS\\t\\tUPTIME\\t\\tRESTARTS\\tHEALTH'));
+    console.log('─'.repeat(70));
+
+    for (const status of statuses) {
+      const statusColor = status.status === 'running' ? chalk.green : chalk.red;
+      const healthColor = status.health === 'healthy' ? chalk.green : 
+                         status.health === 'unhealthy' ? chalk.red : chalk.yellow;
+      
+      const uptime = status.uptime > 0 ? formatUptime(status.uptime) : 'N/A';
+      
+      console.log(
+        `${status.name.padEnd(12)}\\t${statusColor(status.status.padEnd(8))}\\t${uptime.padEnd(8)}\\t${status.restarts}\\t\\t${healthColor(status.health)}`
+      );
+    }
+
+    console.log('\\n' + chalk.gray(`Total agents: ${statuses.length}`));
+
+  } catch (error) {
+    throw new Error(`Failed to get status: ${error.message}`);
+  }
+}
+
+async function watchStatus(dockerManager, options) {
+  console.log(chalk.yellow('👀 Watching agent status (Ctrl+C to stop)...\\n'));
+
+  const interval = setInterval(async () => {
+    // Clear screen
+    process.stdout.write('\\x1Bc');
+    
+    console.log(chalk.yellow('📊 Agent Status (Live)\\n'));
+    console.log(chalk.gray(`Last updated: ${new Date().toLocaleTimeString()}\\n`));
+    
+    try {
+      await showStatus(dockerManager, { ...options, json: false });
+    } catch (error) {
+      console.error(chalk.red('Status update failed:'), error.message);
+    }
+  }, 2000);
+
+  process.on('SIGINT', () => {
+    clearInterval(interval);
+    console.log(chalk.yellow('\\n👋 Status monitoring stopped'));
+    process.exit(0);
+  });
+}
+
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+
+module.exports = { statusCommand };

package/lib/cli/stop.js

@@ -0,0 +1,87 @@
+/**
+ * CLI Stop Command - Stop running agents
+ */
+
+const chalk = require('chalk');
+const { DockerManager } = require('../docker/manager');
+
+async function stopCommand(agents, options) {
+  try {
+    const dockerManager = new DockerManager();
+    await dockerManager.initialize();
+
+    if (options.all) {
+      await stopAllAgents(dockerManager, options);
+    } else if (agents.length > 0) {
+      await stopSpecificAgents(dockerManager, agents, options);
+    } else {
+      console.log(chalk.yellow('No agents specified. Use --all to stop all agents or specify agent names.'));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('❌ Stop failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function stopAllAgents(dockerManager, options) {
+  console.log(chalk.yellow('🛑 Stopping all agents...\\n'));
+
+  try {
+    const containers = await dockerManager.docker.listContainers({
+      all: true,
+      filters: { name: ['dank-'] }
+    });
+
+    if (containers.length === 0) {
+      console.log(chalk.gray('No running agents found.'));
+      return;
+    }
+
+    for (const containerInfo of containers) {
+      const agentName = containerInfo.Names[0].replace('/dank-', '').split('-')[0];
+      
+      try {
+        await dockerManager.stopAgent(agentName, options);
+        console.log(chalk.green(`✅ Stopped: ${agentName}`));
+      } catch (error) {
+        console.log(chalk.red(`❌ Failed to stop ${agentName}: ${error.message}`));
+      }
+    }
+
+    console.log(chalk.green('\\n✅ All agents stopped'));
+
+  } catch (error) {
+    throw new Error(`Failed to stop all agents: ${error.message}`);
+  }
+}
+
+async function stopSpecificAgents(dockerManager, agentNames, options) {
+  console.log(chalk.yellow(`🛑 Stopping agents: ${agentNames.join(', ')}\\n`));
+
+  const results = [];
+
+  for (const agentName of agentNames) {
+    try {
+      await dockerManager.stopAgent(agentName, options);
+      console.log(chalk.green(`✅ Stopped: ${agentName}`));
+      results.push({ agent: agentName, status: 'stopped' });
+    } catch (error) {
+      console.log(chalk.red(`❌ Failed to stop ${agentName}: ${error.message}`));
+      results.push({ agent: agentName, status: 'failed', error: error.message });
+    }
+  }
+
+  // Summary
+  const stopped = results.filter(r => r.status === 'stopped').length;
+  const failed = results.filter(r => r.status === 'failed').length;
+
+  console.log(chalk.yellow('\\n📊 Summary:'));
+  console.log(chalk.green(`  ✅ Stopped: ${stopped}`));
+  if (failed > 0) {
+    console.log(chalk.red(`  ❌ Failed: ${failed}`));
+  }
+}
+
+module.exports = { stopCommand };