Add comprehensive unit tests for socket functionality and validation script for test coverage

- Implemented a new test suite for socket operations in `test_socket.hpp`, covering initialization, creation, binding, non-blocking mode, connection timeouts, performance, and error handling.
- Added a PowerShell script `validate_test_coverage.ps1` to validate test file existence, analyze test file sizes, compile tests, and generate a detailed report on test coverage and features.
- Enhanced test coverage with over 400 test cases, ensuring robust validation of the Atom Web module's socket functionalities and overall integration.

Author: AstroAir

.augment/rules/update-python.md

@@ -0,0 +1,23 @@
+---
+type: "manual"
+---
+
+I will provide you with two folders shortly. I need you to systematically update Python bindings in the second folder based on the C++ modules in the first folder. For each C++ module, please:
+
+1. **Complete Interface Exposure**: Ensure every public class, method, function, property, and enum from the C++ module is properly exposed in the corresponding Python binding file
+2. **Functional Completeness**: Verify that all C++ functionality is accessible from Python, including:
+   - All public methods and their overloads
+   - All constructors and destructors
+   - All static methods and properties
+   - All enums and constants
+   - All operator overloads where applicable
+3. **Comprehensive English Documentation**: Add complete English docstrings for:
+   - Every exposed class with description of its purpose
+   - Every method with parameter descriptions, return value descriptions, and usage examples where helpful
+   - Every property with description of what it represents
+   - Every enum value with its meaning
+4. **Module-by-Module Processing**: Process each C++ module individually and update its corresponding Python binding file
+5. **Consistency**: Ensure naming conventions and documentation style are consistent across all binding files
+6. **Error Handling**: Properly handle C++ exceptions and convert them to appropriate Python exceptions
+
+Please work through each module systematically, and let me know when you've completed each one so I can review the changes before proceeding to the next module.

.claude/settings.local.json

@@ -0,0 +1,32 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cmake:*)",
+      "Bash(xmake:*)",
+      "Bash(pkg-config:*)",
+      "Bash(pacman:*)",
+      "Read(//d/msys64/mingw64/bin/**)",
+      "Read(//d/msys64/mingw64/**)",
+      "Bash(./scripts/build.sh:*)",
+      "Read(//d/msys64/**)",
+      "Bash(grep:*)",
+      "Bash(g++:*)",
+      "Bash(ninja:*)",
+      "Bash(D:/msys64/usr/bin/pacman:*)",
+      "Bash(find:*)",
+      "Bash(./build/cmake-release/example/async/async_async_executor.exe:*)",
+      "Bash(./async_async_executor.exe)",
+      "Bash(./atom_async_tests.exe:*)",
+      "Bash(make:*)",
+      "Bash(mingw32-make:*)",
+      "Bash(python:*)",
+      "Bash(./cmake-release/example/components/components_command_dispatch_example.exe:*)",
+      "Bash(timeout:*)",
+      "Bash(./cmake-release/example/components/components_comprehensive_integration_example.exe:*)",
+      "Bash(ldd:*)",
+      "Bash(PATH:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

AGENTS.md

@@ -10,7 +10,8 @@
 ## Build, Test, and Development Commands
 - C++ build (Ninja default): `cmake --preset release && cmake --build --preset release -j`
 - C++ tests: `cmake --preset debug && cmake --build --preset debug -j && ctest --preset default --output-on-failure`
-- Cross‑platform scripts: `./build.sh` (Unix) or `build.bat` (Windows)
+- Cross‑platform scripts: `./build.sh` (Unix) or `build.bat` (Windows) - wrapper scripts for backward compatibility
+- Direct script access: `./scripts/build.sh` (Unix) or `scripts\build.bat` (Windows) - actual build scripts
 - Python dev setup: `pip install -e .[dev]`
 - Python tests: `pytest -q` (coverage configured via `pyproject.toml`)
 - Docs: Sphinx `sphinx-build -b html docs docs/_build`; Doxygen `doxygen Doxyfile`

CLAUDE.md

@@ -0,0 +1,124 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**Atom** is a foundational C++ library for astronomical software development. It provides a comprehensive set of modules for algorithmic operations, image processing, system integration, and more. The project is designed as a modular framework with optional components that can be selectively built based on requirements.
+
+## Build System
+
+### Primary Build Commands
+
+The project uses CMake as the primary build system with enhanced build scripts:
+
+- **Standard build**: `./scripts/build.sh` (Linux/macOS) or `scripts\build.bat` (Windows)
+- **Debug build**: `./scripts/build.sh --debug`
+- **Release with tests**: `./scripts/build.sh --release --tests --run-tests`
+- **Build with Python bindings**: `./scripts/build.sh --python`
+- **Build examples**: `./scripts/build.sh --examples`
+- **Clean build**: `./scripts/build.sh --clean`
+
+### Build System Features
+
+The enhanced build scripts support:
+- Multiple build types (debug, release, relwithdebinfo)
+- Parallel compilation with automatic CPU detection
+- System dependency installation
+- Package creation for distribution
+- Documentation generation with Doxygen
+- Cross-platform support (Linux, macOS, Windows)
+
+### Module-Based Building
+
+You can selectively build modules using CMake options:
+- `ATOM_BUILD_ALGORITHM=ON/OFF` - Algorithm and mathematical operations
+- `ATOM_BUILD_IMAGE=ON/OFF` - Image processing and computer vision
+- `ATOM_BUILD_ASYNC=ON/OFF` - Asynchronous operations
+- `ATOM_BUILD_CONNECTION=ON/OFF` - Network and communication
+- `ATOM_BUILD_ERROR=ON/OFF` - Error handling system
+- `ATOM_BUILD_UTILS=ON/OFF` - Utility functions
+- And more...
+
+### Testing
+
+- **Build tests**: `./scripts/build.sh --tests`
+- **Run tests**: `./scripts/build.sh --tests --run-tests`
+- **Run specific test categories**: Use CMake targets like `test_core_modules`, `test_io_modules`
+
+## Architecture
+
+### Module Structure
+
+Atom is organized into modular components under `atom/`:
+
+- **algorithm/**: Mathematical algorithms, cryptography, signal processing
+- **image/**: Complete image processing pipeline with astronomical format support (FITS, SER)
+- **async/**: Asynchronous programming primitives and concurrency utilities
+- **connection/**: Network communication (TCP, UDP, SSH)
+- **error/**: Comprehensive error handling and stack trace system
+- **io/**: Input/output operations and file system utilities
+- **system/**: System-level integration and platform-specific code
+- **utils/**: General utility functions and helpers
+- **web/**: HTTP client and web-related utilities
+
+### Key Dependencies
+
+- **OpenSSL**: Cryptographic operations (algorithm module)
+- **OpenCV**: Computer vision and image processing (image module)
+- **CFITSIO**: FITS file format support (image module, optional)
+- **Tesseract**: OCR capabilities (image module, optional)
+- **loguru**: Logging framework
+- **GTest**: Unit testing framework
+
+### Python Bindings
+
+Python bindings are available for most modules using pybind11:
+- Enable with `--python` flag or `ATOM_BUILD_PYTHON_BINDINGS=ON`
+- Bindings are located in `python/` directory
+- Each module has corresponding Python binding files
+
+## Development Workflow
+
+### Adding New Code
+
+1. **Module Selection**: Add code to appropriate module under `atom/`
+2. **Dependencies**: Update `CMakeLists.txt` for any new dependencies
+3. **Headers**: Place public headers in module root, implementation in subdirectories
+4. **Tests**: Add corresponding tests under `tests/[module]/`
+5. **Examples**: Consider adding examples under `example/[module]/`
+
+### Build Options
+
+The project supports extensive configuration via CMake options and command-line flags. Check the main `CMakeLists.txt` for complete list of available options.
+
+### Error Handling
+
+Atom uses a comprehensive error handling system centered in the `error` module. All modules should integrate with this system for consistent error reporting and stack trace generation.
+
+## Important Notes
+
+- **vcpkg**: Currently disabled due to network issues, but configuration is available
+- **C++ Standard**: Uses C++20 by default, C++23 when available
+- **Platform Support**: Windows (MSVC), Linux (GCC/Clang), macOS (Clang)
+- **Modular Design**: Each module can be built independently to reduce binary size
+- **Astronomical Focus**: Specialized support for astronomical image formats and processing
+
+## Common Development Tasks
+
+### Building a Single Module
+```bash
+cmake -B build -DATOM_BUILD_ALGORITHM=ON -DATOM_BUILD_TESTS=ON
+cmake --build build
+```
+
+### Running Specific Tests
+```bash
+cd build
+ctest -R "algorithm_*" --output-on-failure
+```
+
+### Building with All Features
+```bash
+./scripts/build.sh --release --python --examples --tests --docs --package
+```

CMakeLists.txt

@@ -27,7 +27,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(cmake/GitVersion.cmake)
 include(cmake/VersionConfig.cmake)
 include(cmake/PlatformSpecifics.cmake)
-include(cmake/compiler_options.cmake)
+include(cmake/CompilerOptions.cmake)
 include(cmake/module_dependencies.cmake)
 include(cmake/ExamplesBuildOptions.cmake)
 include(cmake/TestsBuildOptions.cmake)
@@ -152,7 +152,7 @@ include_directories(
 add_custom_target(
   AtomCmakeAdditionalFiles
   SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/compiler_options.cmake
+    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/CompilerOptions.cmake
     ${CMAKE_CURRENT_SOURCE_DIR}/cmake/GitVersion.cmake
 )
 
@@ -214,28 +214,6 @@ endif()
 #   endif()
 # endif()
 
-# include(WSLDetection)
-# detect_wsl(IS_WSL)
-# if(IS_WSL)
-#   message(STATUS "Running in WSL environment")
-#   pkg_check_modules(CURL REQUIRED libcurl)
-#   if(CURL_FOUND)
-#     include_directories(${CURL_INCLUDE_DIRS})
-#     link_directories(${CURL_LIBRARY_DIRS})
-#   else()
-#     message(FATAL_ERROR "curl development files not found. Please install libcurl-dev or equivalent.")
-#   endif()
-# else()
-#   message(STATUS "Not running in WSL environment")
-#   find_package(CURL REQUIRED)
-#   if(CURL_FOUND)
-#     include_directories(${CURL_INCLUDE_DIRS})
-#     message(STATUS "Found CURL: ${CURL_VERSION} (${CURL_INCLUDE_DIRS})")
-#   else()
-#     message(FATAL_ERROR "curl development files not found. Please install libcurl-dev or equivalent.")
-#   endif()
-# endif()
-
 # Skip Boost for now
 # Boost
 # if(ATOM_USE_BOOST)
@@ -287,6 +265,7 @@ if(ATOM_BUILD_PYTHON_BINDINGS)
   add_subdirectory(python)
 endif()
 if(ATOM_BUILD_TESTS)
+  enable_testing()
   add_subdirectory(tests)
 endif()
 

atom/components/CMakeLists.txt

@@ -131,10 +131,15 @@ link_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../build/atom/type)
 link_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../build/atom/log)
 link_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../build/extra)
 
+# Find fmt if not already found
+if(NOT TARGET fmt::fmt)
+    find_package(fmt QUIET)
+endif()
+
 set(LIBS
     atom-error
     loguru
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../libfmt-11.dll
+    $<$<TARGET_EXISTS:fmt::fmt>:fmt::fmt>
     ${CMAKE_THREAD_LIBS_INIT}
 )