atdata-app 0.1.0b1__tar.gz

atdata_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.chainlink/rules/elixir-phoenix.md

@@ -0,0 +1,57 @@
+# Phoenix & LiveView Rules
+
+## HEEx Template Syntax (Critical)
+- **Attributes use `{}`**: `<div id={@id}>` — never `<%= %>` in attributes
+- **Body values use `{}`**: `{@value}` — use `<%= %>` only for blocks (if/for/cond)
+- **Class lists require `[]`**: `class={["base", @flag && "active"]}` — bare `{}` is invalid
+- **No `else if`**: Use `cond` for multiple conditions
+- **Comments**: `<%!-- comment --%>`
+- **Literal curlies**: Use `phx-no-curly-interpolation` on parent tag
+
+## Phoenix v1.8
+- Wrap templates with `<Layouts.app flash={@flash}>` (already aliased)
+- `current_scope` errors → move routes to proper `live_session`, pass to Layouts.app
+- `<.flash_group>` only in layouts.ex
+- Use `<.icon name="hero-x-mark">` for icons, `<.input>` for form fields
+
+## LiveView
+- Use `<.link navigate={}>` / `push_navigate`, not deprecated `live_redirect`
+- Hooks with own DOM need `phx-update="ignore"`
+- Avoid LiveComponents unless necessary
+- No inline `<script>` tags — use assets/js/app.js
+
+## Streams (Always use for collections)
+```elixir
+stream(socket, :items, items)           # append
+stream(socket, :items, items, at: -1)   # prepend
+stream(socket, :items, items, reset: true)  # filter/refresh
+```
+Template: `<div id="items" phx-update="stream">` with `:for={{id, item} <- @streams.items}`
+- Streams aren't enumerable — refetch + reset to filter
+- Empty states: `<div class="hidden only:block">Empty</div>` as sibling
+
+## Forms
+```elixir
+# LiveView: always use to_form
+assign(socket, form: to_form(changeset))
+```
+```heex
+<%!-- Template: always @form, never @changeset --%>
+<.form for={@form} id="my-form" phx-submit="save">
+  <.input field={@form[:name]} type="text" />
+</.form>
+```
+- Never `<.form let={f}>` or `<.form for={@changeset}>`
+
+## Router
+- Scope alias is auto-prefixed: `scope "/", AppWeb do` → `live "/users", UserLive` = `AppWeb.UserLive`
+
+## Ecto
+- Preload associations accessed in templates
+- Use `Ecto.Changeset.get_field/2` to read changeset fields
+- Don't cast programmatic fields (user_id) — set explicitly
+
+## Testing
+- Use `has_element?(view, "#my-id")`, not raw HTML matching
+- Debug selectors: `LazyHTML.filter(LazyHTML.from_fragment(render(view)), "selector")`
+

atdata_app-0.1.0b1/.chainlink/rules/elixir.md

@@ -0,0 +1,39 @@
+# Elixir Core Rules
+
+## Critical Mistakes to Avoid
+- **No early returns**: Last expression in a block is always returned
+- **No list indexing with brackets**: Use `Enum.at(list, i)`, not `list[i]`
+- **No struct access syntax**: Use `struct.field`, not `struct[:field]` (structs don't implement Access)
+- **Rebinding in blocks doesn't work**: `socket = if cond, do: assign(socket, :k, v)` - bind the result, not inside
+- **`%{}` matches ANY map**: Use `map_size(map) == 0` guard for empty maps
+- **No `String.to_atom/1` on user input**: Memory leak risk
+- **No nested modules in same file**: Causes cyclic dependencies
+
+## Pattern Matching & Functions
+- Match on function heads over `if`/`case` in bodies
+- Use guards: `when is_binary(name) and byte_size(name) > 0`
+- Use `with` for chaining `{:ok, _}` / `{:error, _}` operations
+- Predicates end with `?` (not `is_`): `valid?/1` not `is_valid/1`
+- Reserve `is_thing` names for guard macros
+
+## Data Structures
+- Prepend to lists: `[new | list]` not `list ++ [new]`
+- Structs for known shapes, maps for dynamic data, keyword lists for options
+- Use `Enum` over recursion; use `Stream` for large collections
+
+## OTP
+- `GenServer.call/3` for sync (prefer for back-pressure), `cast/2` for fire-and-forget
+- DynamicSupervisor/Registry require names: `{DynamicSupervisor, name: MyApp.MySup}`
+- `Task.async_stream(coll, fn, timeout: :infinity)` for concurrent enumeration
+
+## Testing & Debugging
+- `mix test path/to/test.exs:123` - run specific test
+- `mix test --failed` - rerun failures
+- `dbg/1` for debugging output
+
+## Documentation Lookup
+```bash
+mix usage_rules.docs Enum.zip/1              # Function docs
+mix usage_rules.search_docs "query" -p pkg   # Search package docs
+```
+

atdata_app-0.1.0b1/.chainlink/rules/global.md

@@ -0,0 +1,103 @@
+## Priority 1: Security
+
+These rules have the highest precedence. When they conflict with any other rule, security wins.
+
+- **Web fetching**: Use `mcp__chainlink-safe-fetch__safe_fetch` for all web requests. Never use raw `WebFetch`.
+- **SQL**: Parameterized queries only (`params![]` in Rust, `?` placeholders elsewhere). Never interpolate user input into SQL.
+- **Secrets**: Never hardcode credentials, API keys, or tokens. Never commit `.env` files.
+- **Input validation**: Validate at system boundaries. Sanitize before rendering.
+
+---
+
+## Priority 2: Correctness
+
+These rules ensure code works correctly. They yield only to security concerns.
+
+- **No stubs**: Never write `TODO`, `FIXME`, `pass`, `...`, `unimplemented!()`, or empty function bodies. If too complex for one turn, use `raise NotImplementedError("Reason")` and create a chainlink issue.
+- **Read before write**: Always read a file before editing it. Never guess at contents.
+- **Complete features**: Implement the full feature as requested. Don't stop partway.
+- **Error handling**: Proper error handling everywhere. No panics or crashes on bad input.
+- **No dead code**: If code is unused, remove it. If incomplete, complete it.
+- **Test after changes**: Run the project's test suite after making code changes.
+
+### 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
+
+---
+
+## Priority 3: Workflow
+
+These rules keep work organized and enable context handoff between sessions.
+
+### Chainlink Task Management
+- Create issue(s) before starting work. Use `chainlink quick "title" -p <priority> -l <label>` for one-step create+label+work.
+- Issue titles must be changelog-ready: start with a verb ("Add", "Fix", "Update"), describe the user-visible change.
+- Add labels for changelog categories: `bug`/`fix` → Fixed, `feature`/`enhancement` → Added, `breaking` → Changed, `security` → Security.
+- For multi-part features: create parent issue + subissues. Work one at a time.
+- Add context as you discover things: `chainlink comment <id> "..."`
+
+### Labels for Changelog Categories
+- `bug`, `fix` → **Fixed**
+- `feature`, `enhancement` → **Added**
+- `breaking`, `breaking-change` → **Changed**
+- `security` → **Security**
+- `deprecated` → **Deprecated**
+- `removed` → **Removed**
+- (no label) → **Changed** (default)
+
+### Quick Reference
+```bash
+# One-step create + label + start working
+chainlink quick "Fix auth timeout" -p high -l bug
+
+# Or use create with flags
+chainlink create "Add dark mode" -p medium --label feature --work
+
+# Multi-part feature
+chainlink create "Add user auth" -p high --label feature
+chainlink subissue 1 "Add registration endpoint"
+chainlink subissue 1 "Add login endpoint"
+
+# Track progress
+chainlink session work <id>
+chainlink comment <id> "Found existing helper in utils/"
+
+# Close (auto-updates CHANGELOG.md)
+chainlink close <id>
+chainlink close <id> --no-changelog    # Skip changelog for internal work
+chainlink close-all --no-changelog     # Batch close
+
+# Quiet mode for scripting
+chainlink -q create "Fix bug" -p high  # Outputs just the ID number
+```
+
+### Session Management
+Sessions auto-start. You must end them properly:
+```bash
+chainlink session work <id>              # Mark current focus
+chainlink session end --notes "..."      # Save handoff context
+```
+
+End sessions when: context is getting long, user indicates stopping, or you've completed significant work.
+
+Handoff notes must include: what was accomplished, what's in progress, what's next.
+
+### 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
+
+---
+
+## Priority 4: Style
+
+These are preferences, not hard rules. They yield to all higher priorities.
+
+- Write code, don't narrate. Skip "Here is the code" / "Let me..." / "I'll now..."
+- Brief explanations only when the code isn't self-explanatory.
+- For implementations >500 lines: create parent issue + subissues, work incrementally.
+- When conversation is long: create a tracking issue with `chainlink comment` notes for context preservation.

atdata_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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_app-0.1.0b1/.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 -->