File Management Automation with Moltbot

// skills/download-organizer.js
module.exports = {
  name: 'download-organizer',
  
  async run({ config, apis }) {
    const downloadsPath = config.downloadsPath || '~/Downloads';
    const files = await apis.fs.listFiles(downloadsPath);
    
    const categories = {
      images: ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg'],
      documents: ['.pdf', '.doc', '.docx', '.txt', '.rtf'],
      archives: ['.zip', '.rar', '.7z', '.tar', '.gz'],
      videos: ['.mp4', '.mov', '.avi', '.mkv'],
      audio: ['.mp3', '.wav', '.aac', '.flac'],
      code: ['.js', '.ts', '.py', '.html', '.css', '.json']
    };
    
    for (const file of files) {
      const ext = file.name.slice(file.name.lastIndexOf('.')).toLowerCase();
      
      for (const [category, extensions] of Object.entries(categories)) {
        if (extensions.includes(ext)) {
          const targetDir = `${downloadsPath}/${category}`;
          await apis.fs.ensureDir(targetDir);
          await apis.fs.move(file.path, `${targetDir}/${file.name}`);
          break;
        }
      }
    }
    
    return { organized: files.length };
  }
};

// skills/file-search.js
module.exports = {
  name: 'file-search',
  
  async run({ query, apis }) {
    // Use AI to understand the query
    const searchParams = await apis.ai.extract({
      prompt: `Extract search parameters from: "${query}"
        Return JSON with: fileType, keywords, timeRange, location`
    });
    
    // Search file system
    const files = await apis.fs.search({
      pattern: searchParams.keywords,
      extensions: searchParams.fileType,
      modifiedAfter: searchParams.timeRange?.start,
      modifiedBefore: searchParams.timeRange?.end,
      path: searchParams.location
    });
    
    // Read content of text files for context
    const results = [];
    for (const file of files.slice(0, 10)) {
      if (file.isText) {
        const content = await apis.fs.read(file.path, 'utf8');
        const relevance = await apis.ai.scoreRelevance(query, content);
        results.push({ ...file, relevance });
      } else {
        results.push(file);
      }
    }
    
    return results.sort((a, b) => (b.relevance || 0) - (a.relevance || 0));
  }
};

// skills/duplicate-cleaner.js
const crypto = require('crypto');

module.exports = {
  name: 'duplicate-cleaner',
  
  async run({ config, apis }) {
    const scanPath = config.scanPath || '~/Downloads';
    const files = await apis.fs.listFiles(scanPath, { recursive: true });
    
    // Group by size first (optimization)
    const bySize = {};
    for (const file of files) {
      if (!bySize[file.size]) bySize[file.size] = [];
      bySize[file.size].push(file);
    }
    
    // Hash potential duplicates
    const duplicates = [];
    for (const [size, sizeGroup] of Object.entries(bySize)) {
      if (sizeGroup.length < 2) continue;
      
      const hashes = {};
      for (const file of sizeGroup) {
        const hash = await this.hashFile(file.path);
        if (hashes[hash]) {
          duplicates.push([file, hashes[hash]]);
        } else {
          hashes[hash] = file;
        }
      }
    }
    
    return {
      duplicates,
      spaceToRecover: duplicates.reduce((sum, [f1, f2]) => sum + f1.size, 0)
    };
  },
  
  async hashFile(path) {
    const content = await apis.fs.read(path);
    return crypto.createHash('md5').update(content).digest('hex');
  }
};