dank-ai 1.0.1 → 1.0.2

package/docker/package.json

@@ -4,16 +4,17 @@
   "description": "Runtime dependencies for Dank agents",
   "private": true,
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.6.0",
     "axios": "^1.5.0",
-    "express": "^4.18.2",
-    "winston": "^3.10.0",
+    "cohere-ai": "^7.0.0",
     "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-rate-limit": "^6.8.1",
     "lodash": "^4.17.21",
-    "uuid": "^9.0.0",
     "moment": "^2.29.4",
     "openai": "^4.0.0",
-    "@anthropic-ai/sdk": "^0.6.0",
-    "cohere-ai": "^7.0.0",
-    "express-rate-limit": "^6.8.1"
+    "uuid": "^9.0.0",
+    "winston": "^3.10.0",
+    "ws": "^8.18.3"
   }
 }

package/example/README.md

@@ -0,0 +1,176 @@
+# 🧪 Dank Agent HTTP Endpoints Test
+
+This directory contains a test configuration with HTTP-enabled agents and their endpoints.
+
+## 🚀 Quick Start
+
+1. **Start the agents:**
+   ```bash
+   cd test
+   dank run
+   ```
+
+2. **Test the endpoints:**
+   ```bash
+   # Install axios for testing (if not already installed)
+   npm install axios
+   
+   # Run endpoint tests
+   node test-endpoints.js
+   
+   # Or run graceful tests (handles errors better)
+   node test-endpoints.js graceful
+   ```
+
+## 🤖 Agents & Endpoints
+
+### API Agent (Port 3000)
+A full-featured API agent with various endpoints:
+
+**Endpoints:**
+- `GET /` - Welcome message and endpoint list
+- `GET /hello?name=YourName` - Simple greeting
+- `POST /chat` - Chat with the AI agent
+- `POST /analyze` - Analyze text content
+- `GET /status` - Agent status and metrics
+- `GET /metrics` - Performance metrics
+
+**Example Usage:**
+```bash
+# Simple greeting
+curl "http://localhost:3000/hello?name=Developer"
+
+# Chat with agent
+curl -X POST "http://localhost:3000/chat" \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello, how can you help me?"}'
+
+# Analyze text with sentiment
+curl -X POST "http://localhost:3000/analyze" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "This is amazing software!", "analysisType": "sentiment"}'
+
+# Get agent status
+curl "http://localhost:3000/status"
+```
+
+### Webhook Agent (Port 3001)
+Specialized agent for handling webhooks from external services:
+
+**Endpoints:**
+- `GET /webhook/test` - Test endpoint status
+- `POST /webhook/github` - GitHub webhook handler
+- `POST /webhook/slack` - Slack webhook handler
+- `POST /webhook/generic` - Generic webhook handler
+
+**Example Usage:**
+```bash
+# Test webhook status
+curl "http://localhost:3001/webhook/test"
+
+# Simulate GitHub webhook
+curl -X POST "http://localhost:3001/webhook/github" \
+  -H "X-GitHub-Event: push" \
+  -H "Content-Type: application/json" \
+  -d '{"repository": {"full_name": "user/repo"}}'
+
+# Simulate Slack webhook
+curl -X POST "http://localhost:3001/webhook/slack" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Hello!", "user_name": "testuser", "channel_name": "#general"}'
+
+# Generic webhook with custom source
+curl -X POST "http://localhost:3001/webhook/generic" \
+  -H "X-Webhook-Source: my-service" \
+  -H "Content-Type: application/json" \
+  -d '{"event": "user_signup", "data": {"email": "test@example.com"}}'
+```
+
+## 🔧 Features Demonstrated
+
+### API Agent Features:
+- ✅ **CORS enabled** - Cross-origin requests allowed
+- ✅ **Rate limiting** - 100 requests per 15 minutes per IP
+- ✅ **Input validation** - Proper error handling for missing data
+- ✅ **JSON responses** - Consistent API response format
+- ✅ **Error handling** - Graceful error responses
+- ✅ **Metrics & monitoring** - Status and performance endpoints
+
+### Webhook Agent Features:
+- ✅ **Multiple webhook types** - GitHub, Slack, generic webhooks
+- ✅ **Header processing** - Reads webhook-specific headers
+- ✅ **Event logging** - Logs incoming webhook events
+- ✅ **Flexible responses** - Different response formats per webhook type
+
+### Security & Performance:
+- ✅ **Port isolation** - Different ports for different services
+- ✅ **Resource limits** - CPU and memory constraints
+- ✅ **Request logging** - All requests are logged
+- ✅ **Graceful error handling** - No crashes on bad requests
+
+## 🧪 Testing Scenarios
+
+The test script (`test-endpoints.js`) covers:
+
+1. **Basic functionality** - All endpoints return expected responses
+2. **Error handling** - Invalid requests return proper error messages  
+3. **Data processing** - POST endpoints process JSON payloads correctly
+4. **Headers** - Webhook endpoints read custom headers
+5. **Response formats** - All responses follow consistent JSON structure
+
+## 📊 Expected Responses
+
+### Successful API Response Format:
+```json
+{
+  "message": "Response message",
+  "agent": "agent-name", 
+  "timestamp": "2024-01-01T12:00:00.000Z",
+  "data": { /* response data */ }
+}
+```
+
+### Error Response Format:
+```json
+{
+  "error": "Error description",
+  "message": "Detailed error message",
+  "timestamp": "2024-01-01T12:00:00.000Z"
+}
+```
+
+## 🔍 Monitoring
+
+While agents are running, you can monitor them:
+
+```bash
+# Check agent status
+dank status
+
+# View agent logs
+dank logs api-agent --follow
+dank logs webhook-agent --follow
+
+# Check container stats
+docker stats $(docker ps -f name=dank- -q)
+```
+
+## 🚨 Troubleshooting
+
+**Connection refused errors:**
+- Make sure agents are running with `dank run`
+- Check if ports 3000 and 3001 are available
+- Verify Docker containers are running: `docker ps`
+
+**Rate limit errors:**
+- Wait 15 minutes for rate limit to reset
+- Or restart the agents to reset counters
+
+**JSON parsing errors:**
+- Ensure Content-Type header is set to `application/json`
+- Verify JSON payload is properly formatted
+
+---
+
+🔥 **Ready to test your HTTP-enabled Dank agents!** 🚀
+

package/example/dank.config.js

@@ -0,0 +1,301 @@
+/**
+ * Dank Agent Configuration - Auto-Detection Features
+ *
+ * This file demonstrates the new auto-detection capabilities:
+ * - Event handlers are auto-enabled only when .addHandler() is used
+ * - Direct prompting is auto-enabled only when .setPrompt() + .setLLM() are set
+ * - HTTP API is auto-enabled only when routes (.get(), .post(), etc.) are added
+ *
+ * No more explicit .enableHttpApi() or .disableEventHandlers() calls needed!
+ * Run 'dank run' to start all defined agents.
+ * 
+ * NOTE: This file uses the local development version (../lib/index.js).
+ * For production use, copy example/dank.config.template.js to your project
+ * and install dank via npm, then update the require statement.
+ */
+
+const { createAgent } = require("dank");
+module.exports = {
+  // Project configuration
+  name: "test-project",
+
+  // Define your agents
+  agents: [
+    // 1. DIRECT PROMPTING ONLY - Auto-enabled because it has setPrompt() + setLLM() + handlers
+    createAgent("prompt-only-agent")
+      .setLLM("openai", {
+        apiKey:
+          "x",
+        model: "gpt-3.5-turbo",
+        temperature: 0.7,
+      })
+      //add in a pre-prompt pipeline that handler that can be used to modify and moderate requests to the prompt before it is sent to the LLM, and handler for when the llm responds with response but before it is sent to the client
+      .setPrompt("You are a helpful assistant that responds to direct prompts.") // ✅ Auto-enables direct prompting
+      .setBaseImage("nodejs-22") //latest is nodejs-20
+      .setPromptingServer({
+        protocol: "http",
+        port: 3000,
+        authentication: false,
+        maxConnections: 50,
+      })
+
+      // HTTP API auto-disabled (no routes added)
+      // Event handlers auto-enabled (handlers added below)
+      .setResources({
+        memory: "512m",
+        cpu: 1,
+      })
+      // Adding handlers auto-enables event handling ✅
+      .addHandler("request_output", (data) => {
+        console.log("[Prompt-Only Agent] LLM Response:", {
+          originalPrompt: data.prompt.substring(0, 50) + "...",
+          finalPrompt: data.finalPrompt
+            ? data.finalPrompt.substring(0, 50) + "..."
+            : "N/A",
+          promptModified: data.promptModified,
+          response: data.response.substring(0, 100) + "...",
+          processingTime: data.processingTime + "ms",
+          model: data.model,
+        });
+      })
+      .addHandler("request_output:start", (data) => {
+        console.log(
+          "[Prompt-Only Agent] Processing prompt:",
+          data.conversationId
+        );
+        console.log("[Prompt-Only Agent] Original prompt:", data.prompt);
+
+        // Example: Add context to the prompt
+        const enhancedPrompt = `Context: You are a helpful assistant. Please be concise and friendly.
+
+User Question: ${data.prompt}`;
+
+        console.log("[Prompt-Only Agent] Enhanced prompt:", enhancedPrompt);
+
+        // Return modified data - this will replace the prompt sent to the LLM
+        return {
+          prompt: enhancedPrompt,
+        };
+      })
+      .addHandler("request_output:end", (data) => {
+        console.log(
+          "[Prompt-Only Agent] Completed in:",
+          data.processingTime + "ms"
+        );
+        console.log(
+          "[Prompt-Only Agent] Original response:",
+          data.response.substring(0, 50) + "..."
+        );
+
+        // Example: Add a simple footer to the response
+        const enhancedResponse = `${data.response}\n\n[Enhanced by Dank Framework]`;
+
+        console.log(
+          "[Prompt-Only Agent] Enhanced response:",
+          enhancedResponse.substring(0, 100) + "..."
+        );
+
+        // Return modified data - this will replace the response sent to the caller
+        return {
+          response: "dank response:" + enhancedResponse,
+        };
+      })
+      .addHandler("error", (error) => {
+        console.error("[Prompt-Only Agent] Error:", error);
+      }),
+
+    /*
+    // 2. HTTP API ONLY - Auto-enabled because it has routes, auto-disabled direct prompting (no setPrompt)
+    createAgent('api-only-agent')
+      .setLLM('openai', {
+        apiKey: process.env.OPENAI_API_KEY,
+        model: 'gpt-4',
+        temperature: 0.5
+      })
+      // ❌ No setPrompt() = Direct prompting auto-disabled
+      .setBaseImage('nodejs-20')
+      // ❌ No more .disableDirectPrompting() or .enableHttpApi() needed!
+      // Direct prompting auto-disabled (no setPrompt())
+      // HTTP API auto-enabled (routes added below)
+      // Event handlers auto-enabled (handlers added below)
+      .enableHttp({
+        port: 3001,
+        cors: true,
+        rateLimit: {
+          windowMs: 15 * 60 * 1000,
+          max: 100
+        }
+      })
+      // Adding routes auto-enables HTTP API ✅
+      .get('/chat', (req, res) => {
+        res.json({
+          message: 'Hello from API-only agent!',
+          query: req.query,
+          timestamp: new Date().toISOString()
+        });
+      })
+      .post('/process', (req, res) => {
+        res.json({
+          processed: true,
+          input: req.body,
+          agent: 'api-only-agent',
+          timestamp: new Date().toISOString()
+        });
+      })
+      .setResources({
+        memory: '1g',
+        cpu: 2
+      })
+      // Adding handlers auto-enables event handling ✅
+      .addHandler('tool:http-server:*', (data) => {
+        console.log('[API-Only Agent] HTTP Activity:', {
+          type: data.type,
+          method: data.method,
+          path: data.path,
+          statusCode: data.statusCode
+        });
+      })
+      .addHandler('tool:http-server:call', (data) => {
+        console.log('[API-Only Agent] Incoming Request:', {
+          method: data.method,
+          path: data.path,
+          hasBody: !!data.body
+        });
+      })
+      .addHandler('tool:http-server:response:post', (data) => {
+        console.log('[API-Only Agent] POST Response:', {
+          path: data.path,
+          statusCode: data.statusCode,
+          processingTime: data.processingTime + 'ms'
+        });
+      }),
+    // 3. MINIMAL AGENT - Auto-disables everything (no setPrompt, no routes, no handlers)
+    createAgent('minimal-agent')
+      .setLLM('anthropic', {
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: 'claude-3-sonnet-20240229',
+        temperature: 0.3
+      })
+      // ❌ No setPrompt() = Direct prompting auto-disabled
+      // ❌ No routes = HTTP API auto-disabled
+      // ❌ No handlers = Event handling auto-disabled
+      .setBaseImage('python-311')
+      // ❌ No more explicit disable calls needed!
+      // All features auto-disabled based on usage
+      .setResources({
+        memory: '1g',
+        cpu: 1
+      }),
+      // This agent only has basic LLM functionality available
+
+    // 4. EVENT HANDLERS ONLY - Auto-enabled because it has handlers, auto-disabled others
+    /*
+    createAgent('event-only-agent')
+      .setLLM('anthropic', {
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: 'claude-3-sonnet-20240229',
+        temperature: 0.3
+      })
+      // ❌ No setPrompt() = Direct prompting auto-disabled
+      // ❌ No routes = HTTP API auto-disabled
+      // ✅ Has handlers = Event handling auto-enabled
+      .setBaseImage('python-311')
+      .setResources({
+        memory: '1g',
+        cpu: 1
+      })
+      // Adding handlers auto-enables event handling ✅
+      .addHandler('output', (data) => {
+        console.log('[Event-Only Agent] Processing output:', data);
+      })
+      .addHandler('error', (error) => {
+        console.error('[Event-Only Agent] Handling error:', error);
+      })
+      .addHandler('custom', (data) => {
+        console.log('[Event-Only Agent] Custom event:', data);
+      }),
+    */
+
+    // 5. FULL-FEATURED AGENT - Auto-enables all features based on usage
+    /*
+    createAgent('full-featured-agent')
+      .setLLM('openai', {
+        apiKey: process.env.OPENAI_API_KEY,
+        model: 'gpt-4',
+        temperature: 0.6
+      })
+      .setPrompt('You are a versatile agent supporting all communication methods.')  // ✅ Auto-enables direct prompting
+      .setBaseImage('latest')
+      .setPromptingServer({
+        protocol: 'websocket',
+        port: 3003,
+        authentication: true,
+        maxConnections: 100
+      })
+      .enableHttp({
+        port: 8080,
+        cors: true
+      })
+      // ❌ No more .enableHttpApi() or .enableEventHandlers() needed!
+      // Direct prompting auto-enabled (has setPrompt() + setLLM())
+      // HTTP API auto-enabled (routes added below)
+      // Event handlers auto-enabled (handlers added below)
+      
+      // Adding routes auto-enables HTTP API ✅
+      .get('/status', (req, res) => {
+        res.json({
+          agent: 'full-featured-agent',
+          features: {
+            directPrompting: 'auto-enabled (has prompt + LLM)',
+            httpApi: 'auto-enabled (has routes)',
+            eventHandlers: 'auto-enabled (has handlers)'
+          },
+          timestamp: new Date().toISOString()
+        });
+      })
+      .post('/chat', (req, res) => {
+        res.json({
+          response: `I received: ${req.body.message}`,
+          via: 'HTTP API',
+          timestamp: new Date().toISOString()
+        });
+      })
+      .setResources({
+        memory: '2g',
+        cpu: 3
+      })
+      // Adding handlers auto-enables event handling ✅
+      .addHandler('output', (data) => {
+        console.log('[Full-Featured Agent] Output:', data);
+      })
+      .addHandler('error', (error) => {
+        console.error('[Full-Featured Agent] Error:', error);
+      })
+      .addHandler('heartbeat', () => {
+        console.log('[Full-Featured Agent] Heartbeat - All systems operational');
+      })
+      // Event patterns for all communication methods
+      .addHandler('request_output', (data) => {
+        console.log('[Full-Featured Agent] Direct Prompt Response:', {
+          conversationId: data.conversationId,
+          responseLength: data.response.length,
+          processingTime: data.processingTime + 'ms'
+        });
+      })
+      .addHandler('tool:http-server:call:post', (data) => {
+        console.log('[Full-Featured Agent] HTTP POST Call:', {
+          path: data.path,
+          bodySize: JSON.stringify(data.body).length
+        });
+      })
+      .addHandler('tool:http-server:response', (data) => {
+        console.log('[Full-Featured Agent] HTTP Response:', {
+          method: data.method,
+          path: data.path,
+          status: data.statusCode,
+          time: data.processingTime + 'ms'
+        });
+      })
+    */
+  ],
+};

package/lib/agent.js

@@ -110,39 +110,34 @@ class DankAgent {
     return this;
   }
 
-  /**
-   * Set the main port that the agent will expose
-   */
-  setPort(port) {
-    if (typeof port !== 'number' || port < 1000 || port > 65535) {
-      throw new Error('Port must be a number between 1000 and 65535');
-    }
-    
-    this.config.docker = { ...this.config.docker, port };
-    return this;
-  }
 
   /**
-   * Enable or configure direct prompting communication
+   * Configure prompting server settings
    */
-  enableDirectPrompting(options = {}) {
+  setPromptingServer(options = {}) {
     const schema = Joi.object({
-      protocol: Joi.string().valid('websocket', 'tcp', 'http').default('websocket'),
+      protocol: Joi.string().valid('websocket', 'tcp', 'http').default('http'),
+      port: Joi.number().min(1000).max(65535).default(3000),
       authentication: Joi.boolean().default(false),
-      maxConnections: Joi.number().min(1).max(1000).default(100),
+      maxConnections: Joi.number().min(1).max(1000).default(50),
       timeout: Joi.number().min(1000).default(30000)
     });
 
     const { error, value } = schema.validate(options);
     if (error) {
-      throw new Error(`Invalid direct prompting configuration: ${error.message}`);
+      throw new Error(`Invalid prompting server configuration: ${error.message}`);
     }
 
+    // Set the port in docker config
+    this.config.docker = { ...this.config.docker, port: value.port };
+
+    // Set the communication config (excluding port)
+    const { port, ...communicationConfig } = value;
     this.config.communication = {
       ...this.config.communication,
       directPrompting: {
         enabled: true,
-        ...value
+        ...communicationConfig
       }
     };
 
@@ -568,9 +563,9 @@ class DankAgent {
       communication: Joi.object({
         directPrompting: Joi.object({
           enabled: Joi.boolean().default(false),
-          protocol: Joi.string().valid('websocket', 'tcp', 'http').default('websocket'),
+          protocol: Joi.string().valid('websocket', 'tcp', 'http').default('http'),
           authentication: Joi.boolean().default(false),
-          maxConnections: Joi.number().min(1).max(1000).default(100),
+          maxConnections: Joi.number().min(1).max(1000).default(50),
           timeout: Joi.number().min(1000).default(30000)
         }).default({ enabled: false }),
         httpApi: Joi.object({

package/lib/cli/init.js

@@ -8,9 +8,54 @@ const chalk = require('chalk');
 const { DankProject } = require('../project');
 
 async function initCommand(projectName, options) {
-  const name = projectName || path.basename(process.cwd());
+  let name = projectName;
+  let npmProjectName = projectName;
   
-  console.log(chalk.yellow(`🚀 Initializing Dank project: ${name}\n`));
+  // If no project name provided, prompt for both directory name and npm project name
+  if (!name) {
+    const inquirer = await import('inquirer');
+    const answers = await inquirer.default.prompt([
+      {
+        type: 'input',
+        name: 'projectName',
+        message: 'What should the project directory be named?',
+        default: path.basename(process.cwd()),
+        validate: (input) => {
+          if (!input.trim()) {
+            return 'Project name is required';
+          }
+          if (!/^[a-zA-Z0-9-_]+$/.test(input)) {
+            return 'Project name can only contain letters, numbers, hyphens, and underscores';
+          }
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'npmProjectName',
+        message: 'What should the npm package name be?',
+        default: (answers) => answers.projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        validate: (input) => {
+          if (!input.trim()) {
+            return 'NPM project name is required';
+          }
+          if (!/^[a-z0-9-]+$/.test(input)) {
+            return 'NPM project name can only contain lowercase letters, numbers, and hyphens';
+          }
+          return true;
+        }
+      }
+    ]);
+    
+    name = answers.projectName;
+    npmProjectName = answers.npmProjectName;
+  } else {
+    // If project name provided, use it for both directory and npm name
+    npmProjectName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  }
+  
+  console.log(chalk.yellow(`🚀 Initializing Dank project: ${name}`));
+  console.log(chalk.cyan(`📦 NPM package name: ${npmProjectName}\n`));
 
   try {
     // Create project instance
@@ -23,7 +68,7 @@ async function initCommand(projectName, options) {
     await project.init();
 
     // Create package.json
-    await createPackageJson(name, project.projectPath);
+    await createPackageJson(npmProjectName, project.projectPath);
 
     // Create .env.example file
     await createEnvExample(project.projectPath);
@@ -51,11 +96,11 @@ async function initCommand(projectName, options) {
 /**
  * Create package.json for the new project
  */
-async function createPackageJson(projectName, projectPath) {
+async function createPackageJson(npmProjectName, projectPath) {
   const packageJson = {
-    name: projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+    name: npmProjectName,
     version: '1.0.0',
-    description: `Dank AI agents for ${projectName}`,
+    description: `Dank AI agents for ${npmProjectName}`,
     main: 'dank.config.js',
     scripts: {
       start: 'dank run',
@@ -67,7 +112,7 @@ async function createPackageJson(projectName, projectPath) {
       clean: 'dank clean'
     },
     dependencies: {
-      'dank': '^1.0.0'
+      'dank-ai': '^1.0.0'
     },
     keywords: ['dank', 'ai', 'agents', 'automation', 'llm'],
     author: '',