- Total size: ${(analysis.totalSize / 1024 / 1024).toFixed(2)} MB
- Oldest file: ${analysis.oldestFile?.name || 'None'} (${analysis.oldestFile?.date.toLocaleDateString() || 'N/A'})
- Largest file: ${analysis.largestFile?.name || 'None'} (${((analysis.largestFile?.size || 0) / 1024 / 1024).toFixed(2)} MB)`;
      
      return {
        content: [{
          type: 'text',
          text: report
        }]
      };
    }
    
    case 'organize_downloads': {
      const { dryRun = true } = args;
      const moves = [];
      
      const files = await fs.readdir(DOWNLOADS_DIR);
      
      for (const file of files) {
        const filepath = path.join(DOWNLOADS_DIR, file);
        const stat = await fs.stat(filepath);
        
        if (!stat.isFile()) continue;
        
        const ext = path.extname(file).toLowerCase();
        
        for (const [category, extensions] of Object.entries(FILE_CATEGORIES)) {
          if (extensions.includes(ext)) {
            const targetDir = path.join(DOWNLOADS_DIR, category);
            const targetPath = path.join(targetDir, file);
            
            moves.push({
              from: file,
              to: `${category}/${file}`,
              category
            });
            
            if (!dryRun) {
              await fs.mkdir(targetDir, { recursive: true });
              await fs.rename(filepath, targetPath);
            }
            
            break;
          }
        }
      }
      
      const summary = dryRun 
        ? `Would organize ${moves.length} files:\n${moves.map(m => `- ${m.from} → ${m.to}`).join('\n')}`
        : `Organized ${moves.length} files into categories`;
      
      return {
        content: [{
          type: 'text',
          text: summary
        }]
      };
    }
    
    case 'find_old_downloads': {
      const { days = 30 = args;
      const cutoffDate = new Date();
      cutoffDate.setDate(cutoffDate.getDate() - days);
      
      const files = await fs.readdir(DOWNLOADS_DIR);
      const oldFiles = [];
      
      for (const file of files) {
        const filepath = path.join(DOWNLOADS_DIR, file);
        const stat = await fs.stat(filepath);
        
        if (stat.isFile() && stat.mtime < cutoffDate) {
          oldFiles.push({
            name: file,
            date: stat.mtime,
            size: stat.size,
            ageInDays: Math.floor((Date.now() - stat.mtime) / (1000 * 60 * 60 * 24))
          });
        }
      }
      
      oldFiles.sort((a, b) => a.date - b.date);
      
      const report = oldFiles.length > 0
        ? `Found ${oldFiles.length} files older than ${days} days:\n\n${oldFiles.map(f => 
            `- ${f.name} (${f.ageInDays} days old, ${(f.size / 1024).toFixed(1)} KB)`
          ).join('\n')}`
        : `No files older than ${days} days found`;
      
      return {
        content: [{
          type: 'text',
          text: report
        }]
      };
    }
    
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

// Tool definitions
server.setRequestHandler('tools/list', async () => {
  return {
    tools: [
      {
        name: 'analyze_downloads',
        description: 'Analyze the contents of your Downloads folder',
        inputSchema: {
          type: 'object',
          properties: {}
        }
      },
      {
        name: 'organize_downloads',
        description: 'Organize downloads into folders by file type',
        inputSchema: {
          type: 'object',
          properties: {
            dryRun: {
              type: 'boolean',
              description: 'If true, show what would be done without moving files',
              default: true
            }
          }
        }
      },
      {
        name: 'find_old_downloads',
        description: 'Find files older than specified days',
        inputSchema: {
          type: 'object',
          properties: {
            days: {
              type: 'number',
              description: 'Files older than this many days',
              default: 30
            }
          }
        }
      }
    ]
  };
});

const transport = new StdioServerTransport();
await server.connect(transport);
console.error('Download Organizer MCP Server running...');