atdata 0.1.1a2__tar.gz → 0.2.3b1__tar.gz

atdata-0.2.3b1/.chainlink/rules/c.md

@@ -0,0 +1,43 @@
+### C Best Practices
+
+#### Memory Safety
+- Always check return values of malloc/calloc
+- Free all allocated memory (use tools like valgrind)
+- Initialize all variables before use
+- Use sizeof() with the variable, not the type
+
+```c
+// GOOD: Safe memory allocation
+int *arr = malloc(n * sizeof(*arr));
+if (arr == NULL) {
+    return -1;  // Handle allocation failure
+}
+// ... use arr ...
+free(arr);
+
+// BAD: Unchecked allocation
+int *arr = malloc(n * sizeof(int));
+arr[0] = 1;  // Crash if malloc failed
+```
+
+#### Buffer Safety
+- Always bounds-check array access
+- Use `strncpy`/`snprintf` instead of `strcpy`/`sprintf`
+- Validate string lengths before copying
+
+```c
+// GOOD: Safe string copy
+char dest[64];
+strncpy(dest, src, sizeof(dest) - 1);
+dest[sizeof(dest) - 1] = '\0';
+
+// BAD: Buffer overflow risk
+char dest[64];
+strcpy(dest, src);  // No bounds check
+```
+
+#### Security
+- Never use `gets()` (use `fgets()`)
+- Validate all external input
+- Use constant-time comparison for secrets
+- Avoid integer overflow in size calculations

atdata-0.2.3b1/.chainlink/rules/cpp.md

@@ -0,0 +1,39 @@
+### C++ Best Practices
+
+#### Modern C++ (C++17+)
+- Use smart pointers (`unique_ptr`, `shared_ptr`) over raw pointers
+- Use RAII for resource management
+- Prefer `std::string` and `std::vector` over C arrays
+- Use `auto` for complex types, explicit types for clarity
+
+```cpp
+// GOOD: Modern C++ with smart pointers
+auto config = std::make_unique<Config>();
+auto users = std::vector<User>{};
+
+// BAD: Manual memory management
+Config* config = new Config();
+// ... forgot to delete
+```
+
+#### Error Handling
+- Use exceptions for exceptional cases
+- Use `std::optional` for values that may not exist
+- Use `std::expected` (C++23) or result types for expected failures
+
+```cpp
+// GOOD: Optional for missing values
+std::optional<User> findUser(const std::string& id) {
+    auto it = users.find(id);
+    if (it == users.end()) {
+        return std::nullopt;
+    }
+    return it->second;
+}
+```
+
+#### Security
+- Validate all input boundaries
+- Use `std::string_view` for non-owning string references
+- Avoid C-style casts; use `static_cast`, `dynamic_cast`
+- Never use `sprintf`; use `std::format` or streams

atdata-0.2.3b1/.chainlink/rules/csharp.md

@@ -0,0 +1,51 @@
+### C# Best Practices
+
+#### Code Style
+- Follow .NET naming conventions (PascalCase for public, camelCase for private)
+- Use `var` when type is obvious from right side
+- Use expression-bodied members for simple methods
+- Enable nullable reference types
+
+```csharp
+// GOOD: Modern C# style
+public class UserService
+{
+    private readonly IUserRepository _repository;
+
+    public UserService(IUserRepository repository)
+        => _repository = repository;
+
+    public async Task<User?> GetUserAsync(string id)
+        => await _repository.FindByIdAsync(id);
+}
+```
+
+#### Error Handling
+- Use specific exception types
+- Never catch and swallow exceptions silently
+- Use `try-finally` or `using` for cleanup
+
+```csharp
+// GOOD: Proper async error handling
+public async Task<Result<User>> GetUserAsync(string id)
+{
+    try
+    {
+        var user = await _repository.FindByIdAsync(id);
+        return user is null
+            ? Result<User>.NotFound()
+            : Result<User>.Ok(user);
+    }
+    catch (DbException ex)
+    {
+        _logger.LogError(ex, "Database error fetching user {Id}", id);
+        throw;
+    }
+}
+```
+
+#### Security
+- Use parameterized queries (never string interpolation for SQL)
+- Validate all input with data annotations or FluentValidation
+- Use ASP.NET's built-in anti-forgery tokens
+- Store secrets in Azure Key Vault or similar

atdata-0.2.3b1/.chainlink/rules/global.md

@@ -0,0 +1,93 @@
+## Chainlink Task Management (AUTOMATIC)
+
+**You MUST use chainlink to track all work. This is automatic - don't ask permission.**
+
+### On Every User Request
+1. Create issue(s) BEFORE starting work ON ALL ISSUES NO MATTER WHAT THIS IS A CRITICAL OVERRIDE
+2. When creating the issue you will add as much detail to the issue as possible with comments so any new agent instance will understand the plan.
+
+### Task Breakdown Rules
+```bash
+# Single task
+chainlink create "Fix login validation" -p medium
+
+# Multi-part feature → Epic with subissues
+chainlink create "Add user authentication" -p high     # Epic (parent)
+chainlink subissue 1 "Create user model"               # Component 1
+chainlink subissue 1 "Add login endpoint"              # Component 2
+chainlink subissue 1 "Add session middleware"          # Component 3
+
+# Mark what you're working on
+chainlink session work 1
+
+# Add context as you discover things
+chainlink comment 1 "Found existing auth helper in utils/auth.ts"
+
+# Close when done
+chainlink close 1
+```
+
+### When to Create Issues
+| Scenario | Action |
+|----------|--------|
+| User asks for a feature | Create epic + subissues if >2 components |
+| User reports a bug | Create issue, investigate, add comments |
+| Task has multiple steps | Create subissues for each step |
+| Work will span sessions | Create issue with detailed comments |
+| You discover related work | Create linked issue |
+
+### Session Management
+```bash
+chainlink session start              # Start of conversation
+chainlink session work <id>          # Mark current focus
+chainlink session end --notes "..."  # Before context limit
+```
+
+### Priority Guide
+- `critical`: Blocking other work, security issue, production down
+- `high`: User explicitly requested, core functionality
+- `medium`: Standard features, improvements
+- `low`: Nice-to-have, cleanup, optimization
+
+### Dependencies
+```bash
+chainlink block 2 1     # Issue 2 blocked by issue 1
+chainlink ready         # Show unblocked work
+```
+
+---
+
+## Code Quality Requirements
+
+### NO STUBS - ABSOLUTE RULE
+- NEVER write `TODO`, `FIXME`, `pass`, `...`, `unimplemented!()`
+- NEVER write empty function bodies or placeholder returns
+- If too complex for one turn: `raise NotImplementedError("Reason")` + create chainlink issue
+
+### Core Rules
+1. **READ BEFORE WRITE**: Always read a file before editing
+2. **FULL FEATURES**: Complete the feature, don't stop partway
+3. **ERROR HANDLING**: No panics/crashes on bad input
+4. **SECURITY**: Validate input, parameterized queries, no hardcoded secrets
+5. **NO DEAD CODE**: Remove or complete incomplete code
+
+### Pre-Coding Grounding
+Before using unfamiliar libraries/APIs:
+1. **VERIFY IT EXISTS**: WebSearch to confirm the API
+2. **CHECK THE DOCS**: Real function signatures, not guessed
+3. **USE LATEST VERSIONS**: Check for current stable release
+
+### Conciseness
+- Write code, don't narrate
+- Skip "Here is the code" / "Let me..." / "I'll now..."
+- Brief explanations only when code isn't self-explanatory
+
+### Large Implementations (500+ lines)
+1. Create parent issue: `chainlink create "<feature>" -p high`
+2. Break into subissues: `chainlink subissue <id> "<component>"`
+3. Work one subissue at a time, close each when done
+
+### Context Window Management
+When conversation is long or task needs many steps:
+1. Create tracking issue: `chainlink create "Continue: <summary>" -p high`
+2. Add notes: `chainlink comment <id> "<what's done, what's next>"`

atdata-0.2.3b1/.chainlink/rules/go.md

@@ -0,0 +1,44 @@
+### Go Best Practices
+
+#### Code Style
+- Use `gofmt` for formatting
+- Use `golint` and `go vet` for linting
+- Follow effective Go guidelines
+- Keep functions short and focused
+
+#### Error Handling
+```go
+// GOOD: Check and handle errors
+func readConfig(path string) (*Config, error) {
+    data, err := os.ReadFile(path)
+    if err != nil {
+        return nil, fmt.Errorf("reading config: %w", err)
+    }
+
+    var config Config
+    if err := json.Unmarshal(data, &config); err != nil {
+        return nil, fmt.Errorf("parsing config: %w", err)
+    }
+    return &config, nil
+}
+
+// BAD: Ignoring errors
+func readConfig(path string) *Config {
+    data, _ := os.ReadFile(path)  // Don't ignore errors
+    var config Config
+    json.Unmarshal(data, &config)
+    return &config
+}
+```
+
+#### Concurrency
+- Use channels for communication between goroutines
+- Use `sync.WaitGroup` for waiting on multiple goroutines
+- Use `context.Context` for cancellation and timeouts
+- Avoid shared mutable state; prefer message passing
+
+#### Security
+- Use `html/template` for HTML output (auto-escaping)
+- Use parameterized queries for SQL
+- Validate all input at API boundaries
+- Use `crypto/rand` for secure random numbers

atdata-0.2.3b1/.chainlink/rules/java.md

@@ -0,0 +1,42 @@
+### Java Best Practices
+
+#### Code Style
+- Follow Google Java Style Guide or project conventions
+- Use meaningful variable and method names
+- Keep methods short (< 30 lines)
+- Prefer composition over inheritance
+
+#### Error Handling
+```java
+// GOOD: Specific exceptions with context
+public Config readConfig(Path path) throws ConfigException {
+    try {
+        String content = Files.readString(path);
+        return objectMapper.readValue(content, Config.class);
+    } catch (IOException e) {
+        throw new ConfigException("Failed to read config: " + path, e);
+    } catch (JsonProcessingException e) {
+        throw new ConfigException("Invalid JSON in config: " + path, e);
+    }
+}
+
+// BAD: Catching generic Exception
+public Config readConfig(Path path) {
+    try {
+        return objectMapper.readValue(Files.readString(path), Config.class);
+    } catch (Exception e) {
+        return null;  // Swallowing error
+    }
+}
+```
+
+#### Security
+- Use PreparedStatement for SQL (never string concatenation)
+- Validate all user input
+- Use secure random (SecureRandom) for security-sensitive operations
+- Never log sensitive data (passwords, tokens)
+
+#### Testing
+- Use JUnit 5 for unit tests
+- Use Mockito for mocking dependencies
+- Aim for high coverage on business logic

atdata-0.2.3b1/.chainlink/rules/javascript-react.md

@@ -0,0 +1,44 @@
+### JavaScript/React Best Practices
+
+#### Component Structure
+- Use functional components with hooks
+- Keep components small and focused (< 200 lines)
+- Extract custom hooks for reusable logic
+- Use PropTypes for runtime type checking
+
+```javascript
+// GOOD: Clear component with PropTypes
+import PropTypes from 'prop-types';
+
+const UserCard = ({ user, onSelect }) => {
+    return (
+        <div onClick={() => onSelect(user.id)}>
+            {user.name}
+        </div>
+    );
+};
+
+UserCard.propTypes = {
+    user: PropTypes.shape({
+        id: PropTypes.string.isRequired,
+        name: PropTypes.string.isRequired,
+    }).isRequired,
+    onSelect: PropTypes.func.isRequired,
+};
+```
+
+#### State Management
+- Use `useState` for local state
+- Use `useReducer` for complex state logic
+- Lift state up only when needed
+- Consider context for deeply nested prop drilling
+
+#### Performance
+- Use `React.memo` for expensive pure components
+- Use `useMemo` and `useCallback` appropriately
+- Avoid inline object/function creation in render
+
+#### Security
+- Never use `dangerouslySetInnerHTML` with user input
+- Sanitize URLs before using in `href` or `src`
+- Validate props at component boundaries

atdata-0.2.3b1/.chainlink/rules/javascript.md

@@ -0,0 +1,36 @@
+### JavaScript Best Practices
+
+#### Code Style
+- Use `const` by default, `let` when needed, never `var`
+- Use arrow functions for callbacks
+- Use template literals over string concatenation
+- Use destructuring for object/array access
+
+#### Error Handling
+```javascript
+// GOOD: Proper async error handling
+async function fetchUser(id) {
+    try {
+        const response = await fetch(`/api/users/${id}`);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return await response.json();
+    } catch (error) {
+        console.error('Failed to fetch user:', error);
+        throw error;  // Re-throw or handle appropriately
+    }
+}
+
+// BAD: Ignoring errors
+async function fetchUser(id) {
+    const response = await fetch(`/api/users/${id}`);
+    return response.json();  // No error handling
+}
+```
+
+#### Security
+- Never use `eval()` or `innerHTML` with user input
+- Validate all input on both client and server
+- Use `textContent` instead of `innerHTML` when possible
+- Sanitize URLs before navigation or fetch

atdata-0.2.3b1/.chainlink/rules/kotlin.md

@@ -0,0 +1,44 @@
+### Kotlin Best Practices
+
+#### Code Style
+- Follow Kotlin coding conventions
+- Use `val` over `var` when possible
+- Use data classes for simple data holders
+- Leverage null safety features
+
+```kotlin
+// GOOD: Idiomatic Kotlin
+data class User(val id: String, val name: String)
+
+class UserService(private val repository: UserRepository) {
+    fun findUser(id: String): User? =
+        repository.find(id)
+
+    fun getOrCreateUser(id: String, name: String): User =
+        findUser(id) ?: repository.create(User(id, name))
+}
+```
+
+#### Null Safety
+- Avoid `!!` (force non-null); use safe calls instead
+- Use `?.let {}` for conditional execution
+- Use Elvis operator `?:` for defaults
+
+```kotlin
+// GOOD: Safe null handling
+val userName = user?.name ?: "Unknown"
+user?.let { saveToDatabase(it) }
+
+// BAD: Force unwrapping
+val userName = user!!.name  // Crash if null
+```
+
+#### Coroutines
+- Use structured concurrency with `CoroutineScope`
+- Handle exceptions in coroutines properly
+- Use `withContext` for context switching
+
+#### Security
+- Use parameterized queries
+- Validate input at boundaries
+- Use sealed classes for exhaustive error handling

atdata-0.2.3b1/.chainlink/rules/odin.md

@@ -0,0 +1,53 @@
+### Odin Best Practices
+
+#### Code Style
+- Follow Odin naming conventions
+- Use `snake_case` for procedures and variables
+- Use `Pascal_Case` for types
+- Prefer explicit over implicit
+
+```odin
+// GOOD: Clear Odin code
+User :: struct {
+    id:   string,
+    name: string,
+}
+
+find_user :: proc(id: string) -> (User, bool) {
+    user, found := repository[id]
+    return user, found
+}
+```
+
+#### Error Handling
+- Use multiple return values for errors
+- Use `or_return` for early returns
+- Create explicit error types when needed
+
+```odin
+// GOOD: Explicit error handling
+Config_Error :: enum {
+    File_Not_Found,
+    Parse_Error,
+}
+
+load_config :: proc(path: string) -> (Config, Config_Error) {
+    data, ok := os.read_entire_file(path)
+    if !ok {
+        return {}, .File_Not_Found
+    }
+    defer delete(data)
+
+    config, parse_ok := parse_config(data)
+    if !parse_ok {
+        return {}, .Parse_Error
+    }
+    return config, nil
+}
+```
+
+#### Memory Management
+- Use explicit allocators
+- Prefer temp allocator for short-lived allocations
+- Use `defer` for cleanup
+- Be explicit about ownership

atdata-0.2.3b1/.chainlink/rules/php.md

@@ -0,0 +1,46 @@
+### PHP Best Practices
+
+#### Code Style
+- Follow PSR-12 coding standard
+- Use strict types: `declare(strict_types=1);`
+- Use type hints for parameters and return types
+- Use Composer for dependency management
+
+```php
+<?php
+declare(strict_types=1);
+
+// GOOD: Typed, modern PHP
+class UserService
+{
+    public function __construct(
+        private readonly UserRepository $repository
+    ) {}
+
+    public function findUser(string $id): ?User
+    {
+        return $this->repository->find($id);
+    }
+}
+```
+
+#### Error Handling
+- Use exceptions for error handling
+- Create custom exception classes
+- Never suppress errors with `@`
+
+#### Security
+- Use PDO with prepared statements (never string interpolation)
+- Use `password_hash()` and `password_verify()` for passwords
+- Validate and sanitize all user input
+- Use CSRF tokens for forms
+- Set secure cookie flags
+
+```php
+// GOOD: Prepared statement
+$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
+$stmt->execute(['id' => $id]);
+
+// BAD: SQL injection vulnerability
+$result = $pdo->query("SELECT * FROM users WHERE id = '$id'");
+```

atdata-0.2.3b1/.chainlink/rules/project.md

@@ -0,0 +1,5 @@
+<!-- Project-Specific Rules -->
+<!-- Add rules specific to your project here. Examples: -->
+<!-- - Don't modify the /v1/ API endpoints without approval -->
+<!-- - Always update CHANGELOG.md when adding features -->
+<!-- - Database migrations must be backward-compatible -->

atdata-0.2.3b1/.chainlink/rules/python.md

@@ -0,0 +1,44 @@
+### Python Best Practices
+
+#### Code Style
+- Follow PEP 8 style guide
+- Use type hints for function signatures
+- Use `black` for formatting, `ruff` or `flake8` for linting
+- Prefer `pathlib.Path` over `os.path` for path operations
+- Use context managers (`with`) for file operations
+
+#### Error Handling
+```python
+# GOOD: Specific exceptions with context
+def read_config(path: Path) -> dict:
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        raise ConfigError(f"Config file not found: {path}")
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Invalid JSON in {path}: {e}")
+
+# BAD: Bare except or swallowing errors
+def read_config(path):
+    try:
+        return json.load(open(path))
+    except:  # Don't do this
+        return {}
+```
+
+#### Security
+- Never use `eval()` or `exec()` on user input
+- Use `subprocess.run()` with explicit args, never `shell=True` with user input
+- Use parameterized queries for SQL (never f-strings)
+- Validate and sanitize all external input
+
+#### Dependencies
+- Pin dependency versions in `requirements.txt`
+- Use virtual environments (`venv` or `poetry`)
+- Run `pip-audit` to check for vulnerabilities
+
+#### Testing
+- Use `pytest` for testing
+- Aim for high coverage with `pytest-cov`
+- Mock external dependencies with `unittest.mock`

atdata-0.2.3b1/.chainlink/rules/ruby.md

@@ -0,0 +1,47 @@
+### Ruby Best Practices
+
+#### Code Style
+- Follow Ruby Style Guide (use RuboCop)
+- Use 2 spaces for indentation
+- Prefer symbols over strings for hash keys
+- Use `snake_case` for methods and variables
+
+```ruby
+# GOOD: Idiomatic Ruby
+class UserService
+  def initialize(repository)
+    @repository = repository
+  end
+
+  def find_user(id)
+    @repository.find(id)
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+end
+
+# BAD: Non-idiomatic
+class UserService
+  def initialize(repository)
+    @repository = repository
+  end
+  def findUser(id)  # Wrong naming
+    begin
+      @repository.find(id)
+    rescue
+      return nil
+    end
+  end
+end
+```
+
+#### Error Handling
+- Use specific exception classes
+- Don't rescue `Exception` (too broad)
+- Use `ensure` for cleanup
+
+#### Security
+- Use parameterized queries (ActiveRecord does this by default)
+- Sanitize user input in views (Rails does this by default)
+- Never use `eval` or `send` with user input
+- Use `strong_parameters` in Rails controllers

atdata-0.2.3b1/.chainlink/rules/rust.md

@@ -0,0 +1,48 @@
+### Rust Best Practices
+
+#### Code Style
+- Use `rustfmt` for formatting (run `cargo fmt` before committing)
+- Use `clippy` for linting (run `cargo clippy -- -D warnings`)
+- Prefer `?` operator over `.unwrap()` for error handling
+- Use `anyhow::Result` for application errors, `thiserror` for library errors
+- Avoid `.clone()` unless necessary - prefer references
+- Use `&str` for function parameters, `String` for owned data
+
+#### Error Handling
+```rust
+// GOOD: Propagate errors with context
+fn read_config(path: &Path) -> Result<Config> {
+    let content = fs::read_to_string(path)
+        .context("Failed to read config file")?;
+    serde_json::from_str(&content)
+        .context("Failed to parse config")
+}
+
+// BAD: Panic on error
+fn read_config(path: &Path) -> Config {
+    let content = fs::read_to_string(path).unwrap();  // Don't do this
+    serde_json::from_str(&content).unwrap()
+}
+```
+
+#### Memory Safety
+- Never use `unsafe` without explicit justification and review
+- Prefer `Vec` over raw pointers
+- Use `Arc<Mutex<T>>` for shared mutable state across threads
+- Avoid `static mut` - use `lazy_static` or `once_cell` instead
+
+#### Testing
+- Write unit tests with `#[cfg(test)]` modules
+- Use `tempfile` for tests involving filesystem
+- Run `cargo test` before committing
+- Use `cargo tarpaulin` for coverage reports
+
+#### SQL Injection Prevention
+Always use parameterized queries with `rusqlite::params![]`:
+```rust
+// GOOD
+conn.execute("INSERT INTO users (name) VALUES (?1)", params![name])?;
+
+// BAD - SQL injection vulnerability
+conn.execute(&format!("INSERT INTO users (name) VALUES ('{}')", name), [])?;
+```