dank-ai 1.0.48 → 1.0.50

package/README.md

@@ -70,6 +70,7 @@ dank logs assistant --follow
 ```
 my-project/
 ├── dank.config.js         # Agent configuration
+├── .dankignore           # Build ignore patterns (optional)
 ├── agents/                # Custom agent code (optional)
 │   └── example-agent.js
 └── .dank/                 # Generated files
@@ -495,6 +496,68 @@ Dank uses a layered Docker approach:
 2. **Agent Images**: Extend base image with agent-specific code
 3. **Containers**: Running instances with resource limits and networking
 
+### Build File Management (.dankignore)
+
+Dank automatically copies files from your project directory into Docker containers during the build process. Use `.dankignore` to control which files are included.
+
+**Default Behavior:**
+- If `.dankignore` doesn't exist: **All files** are copied to the container
+- If `.dankignore` exists: Only files **not matching** the patterns are copied
+
+**Creating `.dankignore`:**
+```bash
+# Created automatically during dank init
+dank init my-project
+
+# Or create manually
+touch .dankignore
+```
+
+**Example `.dankignore`:**
+```
+# Security - Environment variables (IMPORTANT: Never commit .env files!)
+.env
+.env.*
+*.key
+*.pem
+secrets/
+
+# Dependencies (installed fresh in container)
+node_modules/
+
+# Version control
+.git/
+
+# Build artifacts
+dist/
+build/
+coverage/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE files
+.vscode/
+.idea/
+
+# Logs
+*.log
+logs/
+```
+
+**Pattern Matching:**
+- `node_modules` - Exact match
+- `*.log` - Wildcard (matches any `.log` file)
+- `dist/` - Directory pattern (matches `dist` directory and contents)
+- `.env.*` - Pattern matching (matches `.env.local`, `.env.production`, etc.)
+
+**Best Practices:**
+- ✅ Always exclude `.env` files (security)
+- ✅ Exclude `node_modules/` (dependencies installed in container)
+- ✅ Exclude build artifacts (`dist/`, `build/`)
+- ✅ Include source files, assets, and configuration needed at runtime
+
 ### Container Features
 - **Isolated Environments**: Each agent runs in its own container
 - **Resource Limits**: Memory and CPU constraints per agent
@@ -780,7 +843,7 @@ docker logs container-id
 - **Authentication**: `docker login ghcr.io`
 - **Push Permissions**: Check namespace permissions
 - **Image Exists**: Use different tag or `--force`
-- **Build Context**: Add `.dockerignore` file
+- **Build Context**: Add `.dankignore` file to control which files are copied
 </details>
 
 ## 📦 Package Exports

package/lib/cli/init.js

@@ -84,6 +84,9 @@ async function initCommand(projectName, options) {
     // Create .gitignore
     await createGitignore(project.projectPath);
 
+    // Create .dankignore
+    await createDankIgnore(project.projectPath);
+
     // Create README.md
     await createReadme(name, project.projectPath);
 
@@ -260,6 +263,65 @@ jspm_packages/
   console.log(chalk.green(`Created .gitignore: ${gitignorePath}`));
 }
 
+/**
+ * Create .dankignore file
+ */
+async function createDankIgnore(projectPath) {
+  const dankIgnore = `# Dank Build Ignore Patterns
+# Files and directories to exclude from Docker builds
+# This file is optional - if it doesn't exist, all files will be copied
+
+# Security - Environment variables (IMPORTANT: Never commit .env files!)
+.env
+.env.*
+*.key
+*.pem
+secrets/
+
+# Dependencies (installed fresh in container)
+node_modules/
+
+# Version control
+.git/
+
+# Build artifacts
+dist/
+build/
+coverage/
+.nyc_output/
+
+# OS files
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+
+# IDE files
+.vscode/
+.idea/
+*.sublime-*
+*.code-workspace
+
+# Logs
+*.log
+logs/
+
+# Dank framework
+.dank/
+.build-context-*
+
+# Temporary files
+*.tmp
+*.temp
+.cache/
+`;
+
+  const dankIgnorePath = path.join(projectPath, '.dankignore');
+  await fs.writeFile(dankIgnorePath, dankIgnore, 'utf8');
+  console.log(chalk.green(`Created .dankignore: ${dankIgnorePath}`));
+}
+
 /**
  * Create README.md for the project
  */

package/lib/docker/manager.js

@@ -1759,6 +1759,141 @@ class DockerManager {
    * @param {object} options - Additional options
    * @param {string} options.projectRoot - Root directory for package.json (defaults to process.cwd())
    */
+  /**
+   * Read .dankignore file if it exists
+   * @param {string} projectDir - Project directory
+   * @returns {string[]} Array of ignore patterns
+   */
+  async readDankIgnore(projectDir) {
+    const dankIgnorePath = path.join(projectDir, '.dankignore');
+    
+    if (!(await fs.pathExists(dankIgnorePath))) {
+      // No .dankignore = copy everything
+      return [];
+    }
+    
+    try {
+      const content = await fs.readFile(dankIgnorePath, 'utf8');
+      return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => {
+          // Remove comments and empty lines
+          return line && !line.startsWith('#');
+        });
+    } catch (error) {
+      this.logger.warn(`⚠️  Failed to read .dankignore: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Check if a file path should be ignored based on .dankignore patterns
+   * @param {string} filePath - Full path to the file
+   * @param {string} projectDir - Project root directory
+   * @param {string[]} ignorePatterns - Patterns from .dankignore
+   * @returns {boolean} True if file should be ignored
+   */
+  shouldIgnoreFile(filePath, projectDir, ignorePatterns) {
+    if (ignorePatterns.length === 0) {
+      return false; // No patterns = don't ignore anything
+    }
+
+    // Get relative path from project directory
+    const relativePath = path.relative(projectDir, filePath);
+    const normalizedPath = relativePath.replace(/\\/g, '/'); // Normalize to forward slashes
+    
+    // Also check just the filename for patterns like "*.log"
+    const fileName = path.basename(filePath);
+    
+    for (const pattern of ignorePatterns) {
+      // Skip package.json and package-lock.json as they're handled separately
+      if (pattern === 'package.json' || pattern === 'package-lock.json') {
+        continue;
+      }
+      
+      // Convert pattern to regex
+      // Support:
+      // - Exact matches: "node_modules"
+      // - Wildcards: "*.log", ".env.*"
+      // - Directory patterns: "dist/", "node_modules/"
+      // - Path patterns: "secrets/*.key"
+      
+      // Use a placeholder for * to avoid escaping issues
+      const placeholder = '__WILDCARD_PLACEHOLDER__';
+      let regexPattern = pattern.replace(/\*/g, placeholder);
+      
+      // Escape special regex characters (except our placeholder)
+      regexPattern = regexPattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+      
+      // Replace placeholder with .* for wildcard matching
+      regexPattern = regexPattern.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), '.*');
+      
+      // If pattern ends with /, it's a directory pattern
+      const isDirectoryPattern = pattern.endsWith('/');
+      
+      // For directory patterns, match anywhere in path
+      // For file patterns, match full path or filename
+      if (isDirectoryPattern) {
+        // Remove trailing / from pattern for matching
+        const dirPattern = regexPattern.replace(/\/$/, '');
+        // Match if path contains this directory (at any level)
+        const dirRegex = new RegExp(`(^|/)${dirPattern}(/|$)`);
+        if (dirRegex.test(normalizedPath)) {
+          return true;
+        }
+      } else {
+        // File pattern - check full path and filename
+        const fileRegex = new RegExp(`^${regexPattern}$`);
+        if (fileRegex.test(normalizedPath) || fileRegex.test(fileName)) {
+          return true;
+        }
+        
+        // Also check if pattern matches any path segment
+        const pathSegments = normalizedPath.split('/');
+        for (const segment of pathSegments) {
+          if (fileRegex.test(segment)) {
+            return true;
+          }
+        }
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Recursively copy files respecting .dankignore patterns
+   * @param {string} sourceDir - Source directory
+   * @param {string} destDir - Destination directory
+   * @param {string} projectDir - Project root (for relative path calculation)
+   * @param {string[]} ignorePatterns - Patterns from .dankignore
+   */
+  async copyFilesRecursive(sourceDir, destDir, projectDir, ignorePatterns) {
+    const items = await fs.readdir(sourceDir);
+    
+    for (const item of items) {
+      const sourcePath = path.join(sourceDir, item);
+      const destPath = path.join(destDir, item);
+      
+      // Check if this file/directory should be ignored
+      if (this.shouldIgnoreFile(sourcePath, projectDir, ignorePatterns)) {
+        continue;
+      }
+      
+      const stat = await fs.stat(sourcePath);
+      
+      if (stat.isDirectory()) {
+        // Recursively copy directory
+        await fs.ensureDir(destPath);
+        await this.copyFilesRecursive(sourcePath, destPath, projectDir, ignorePatterns);
+      } else if (stat.isFile()) {
+        // Copy file
+        await fs.copy(sourcePath, destPath);
+      }
+    }
+  }
+
   async copyProjectFiles(projectDir, contextDir, options = {}) {
     const agentCodeDir = path.join(contextDir, "agent-code");
     await fs.ensureDir(agentCodeDir);
@@ -1783,53 +1918,45 @@ class DockerManager {
       this.logger.warn(`⚠️ Failed to copy package files: ${error.message}`);
     }
     
-    // Patterns to exclude when copying project files
-    const ignorePatterns = [
-      'node_modules',
-      '.git',
-      '.build-context-*',
-      '.env',
-      '.env.*',
-      '*.log',
-      '.DS_Store',
-      'dist',
-      'build',
-      '.dank',
-      'coverage',
-      '.nyc_output',
-      'package.json',      // Already copied from project root
-      'package-lock.json'  // Already copied from project root
-    ];
+    // Read .dankignore patterns from project root (optional - if file doesn't exist, copy everything)
+    // Check both projectRoot and projectDir for .dankignore
+    let ignorePatterns = await this.readDankIgnore(projectRoot);
+    if (ignorePatterns.length === 0 && projectDir !== projectRoot) {
+      ignorePatterns = await this.readDankIgnore(projectDir);
+    }
     
-    try {
-      // Copy all files from project directory, filtering out ignored patterns
-      const items = await fs.readdir(projectDir);
+    // Explicitly copy .env file from project root if it exists
+    // This ensures .env is available at runtime even if it's filtered by .dankignore
+    // We copy to context root (not agent-code/) so it ends up at /app/.env where dotenv.config() looks
+    const envFilePath = path.join(projectRoot, '.env');
+    this.logger.info(`🔍 Checking for .env file at: ${envFilePath}`);
+    
+    if (await fs.pathExists(envFilePath)) {
+      this.logger.info(`✅ .env file found at project root`);
+      const shouldIgnore = this.shouldIgnoreFile(envFilePath, projectRoot, ignorePatterns);
       
-      for (const item of items) {
-        const sourcePath = path.join(projectDir, item);
-        const destPath = path.join(agentCodeDir, item);
-        const stat = await fs.stat(sourcePath);
-        
-        // Skip if matches ignore pattern
-        const shouldIgnore = ignorePatterns.some(pattern => {
-          if (pattern.includes('*')) {
-            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-            return regex.test(item);
-          }
-          return item === pattern;
-        });
-        
-        if (shouldIgnore) {
-          continue;
-        }
-        
-        // Copy file or directory
-        if (stat.isDirectory()) {
-          await fs.copy(sourcePath, destPath);
-        } else if (stat.isFile()) {
-          await fs.copy(sourcePath, destPath);
-        }
+      if (!shouldIgnore) {
+        const destPath = path.join(contextDir, '.env');
+        await fs.copy(envFilePath, destPath);
+        this.logger.info(`📝 Copied .env from project root to context root`);
+      } else {
+        this.logger.info(`⏭️  Skipped .env (matched .dankignore pattern)`);
+        this.logger.info(`   To include .env, remove it from .dankignore`);
       }
+    } else {
+      this.logger.info(`⚠️  .env file not found at project root: ${envFilePath}`);
+      this.logger.info(`   Environment variables will not be available at runtime`);
+    }
+    
+    if (ignorePatterns.length > 0) {
+      this.logger.info(`📋 Using .dankignore with ${ignorePatterns.length} pattern(s)`);
+    } else {
+      this.logger.info(`📋 No .dankignore found - copying all files from ${projectDir}`);
+    }
+    
+    try {
+      // Copy files recursively, respecting .dankignore patterns
+      await this.copyFilesRecursive(projectDir, agentCodeDir, projectDir, ignorePatterns);
       
       this.logger.info(`📁 Copied project files from ${projectDir} to build context`);
     } catch (error) {
@@ -1911,11 +2038,25 @@ WORKDIR /app
 ` : '';
 
     // Create Dockerfile for agent
+    // Copy .env file to /app/ (where entrypoint runs) so dotenv.config() can find it
+    const envFileInContext = path.join(contextDir, '.env');
+    const hasEnvFile = await fs.pathExists(envFileInContext);
+    
+    if (hasEnvFile) {
+      this.logger.info(`📝 .env file found in build context, will be copied to /app/.env in container`);
+    } else {
+      this.logger.info(`⚠️  .env file not found in build context, will not be available in container`);
+    }
+    
+    const envCopyStep = hasEnvFile
+      ? `# Copy .env file to /app/ (where entrypoint runs)\nCOPY .env /app/.env\n`
+      : '';
+    
     const dockerfile = `FROM ${baseImageName}
 ${npmInstallStep}
 # Copy agent code
 COPY agent-code/ /app/agent-code/
-${envStatements}
+${envCopyStep}${envStatements}
 USER dankuser
 `;
 

package/package.json

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