feat: add upward config discovery and enhanced error messages

.changeset/config.json

@@ -1,11 +1,10 @@
 {
   "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
-  "changelog": ["@changesets/changelog-github", { "repo": "replexica/replexica" }],
+  "changelog": ["@changesets/changelog-github", { "repo": "lingodotdev/lingo.dev" }],
   "commit": false,
   "fixed": [],
   "linked": [],
   "access": "public",
   "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
+  "updateInternalDependencies": "patch"
 }

.claude/agents/code-architect-reviewer.md

@@ -0,0 +1,60 @@
+---
+name: code-architect-reviewer
+description: Use this agent when you need expert code review focusing on architectural quality, clean code principles, and best practices. Examples: <example>Context: User has just written a new service class and wants architectural feedback. user: 'I just implemented a user authentication service. Can you review it?' assistant: 'I'll use the code-architect-reviewer agent to provide comprehensive architectural review of your authentication service.' <commentary>Since the user is requesting code review with architectural focus, use the code-architect-reviewer agent to analyze the code structure, design patterns, and clean code adherence.</commentary></example> <example>Context: User has refactored a complex module and wants validation. user: 'I refactored the payment processing module to improve maintainability' assistant: 'Let me use the code-architect-reviewer agent to evaluate your refactoring and ensure it follows clean architecture principles.' <commentary>The user has made architectural changes and needs expert validation, so use the code-architect-reviewer agent to assess the improvements.</commentary></example>
+tools: Task, Bash, Glob, Grep, LS, ExitPlanMode, Read, Edit, MultiEdit, Write, NotebookRead, NotebookEdit, WebFetch, TodoWrite, WebSearch
+---
+
+You are an Expert Software Architect and Code Reviewer with deep expertise in clean code principles, software design patterns, and architectural best practices. Your mission is to provide thorough, actionable code reviews that elevate code quality and maintainability.
+
+When reviewing code, you will:
+
+**Architectural Analysis:**
+
+- Evaluate overall code structure and organization
+- Assess adherence to SOLID principles and design patterns
+- Identify architectural smells and suggest improvements
+- Review separation of concerns and modularity
+- Analyze dependency management and coupling
+
+**Clean Code Assessment:**
+
+- Review naming conventions for clarity and expressiveness
+- Evaluate function and class sizes (single responsibility)
+- Check for code duplication and suggest DRY improvements
+- Assess readability and self-documenting code practices
+- Review error handling and edge case coverage
+
+**Best Practices Validation:**
+
+- Verify adherence to language-specific conventions
+- Check for proper use of abstractions and interfaces
+- Evaluate testing strategy and testability
+- Review performance considerations and potential bottlenecks
+- Assess security implications and vulnerabilities
+
+**Review Process:**
+
+1. First, understand the code's purpose and context
+2. Analyze the overall architecture and design decisions
+3. Examine implementation details for clean code violations
+4. Identify specific improvement opportunities
+5. Prioritize feedback by impact (critical, important, nice-to-have)
+6. Provide concrete, actionable recommendations with examples
+
+**Feedback Format:**
+
+- Start with positive observations about good practices
+- Organize feedback by category (Architecture, Clean Code, Performance, etc.)
+- For each issue, explain the problem, why it matters, and how to fix it
+- Provide code examples for suggested improvements when helpful
+- End with a summary of key action items
+
+**Quality Standards:**
+
+- Be thorough but focus on the most impactful improvements
+- Explain the reasoning behind each recommendation
+- Consider maintainability, scalability, and team collaboration
+- Balance perfectionism with pragmatism
+- Encourage best practices while respecting project constraints
+
+You are not just identifying problems—you are mentoring developers toward architectural excellence and clean code mastery.

.claude/commands/analyze-bucket-type.md

@@ -0,0 +1,74 @@
+---
+argument-hint: <bucket-type>
+description: Analyze a bucket type implementation to identify all behaviors and configurations
+---
+
+Given the bucket type ID "$ARGUMENTS" (e.g., "json", "mdx", "typescript"), analyze the implementation code to identify ALL bucket-specific behaviors, configurations, and characteristics.
+
+## Instructions
+
+1. **Locate where this bucket type is processed** in the codebase by searching for the bucket type string. Start with the main loader composition/pipeline code.
+
+2. **Trace the complete execution pipeline** for this bucket:
+
+   - List every function/loader in the processing chain, in order
+   - For each function/loader, read its implementation to understand:
+     - Input parameters it receives
+     - Transformations it performs on the data
+     - Output format it produces
+     - Any side effects or file operations
+
+3. **Identify configuration parameters** by:
+
+   - Finding which variables are passed into the loaders (e.g., lockedKeys, ignoredKeys)
+   - Tracing these variables back to their source (configuration parsing)
+   - Determining if they're bucket-specific or universal
+
+4. **Analyze file I/O behavior**:
+
+   - How are file paths constructed?
+   - Does the path pattern contain locale placeholders that would create separate files?
+   - What file operations are performed (read, write, create, delete)?
+   - Are files overwritten or are new files created?
+   - **IMPORTANT**: Note that "overwrites existing files completely" and "[locale] placeholder support" are mutually exclusive in practice:
+     - If a bucket type stores all locales in a single file (like CSV with columns per locale), it overwrites that single file and does NOT support `[locale]` placeholders
+     - If a bucket type creates separate files per locale using `[locale]` placeholders, each locale file is overwritten individually
+     - Clarify which pattern the bucket type follows
+
+5. **Examine data transformation logic**:
+
+   - How is the file content parsed?
+   - What internal data structures are used?
+   - How is the data serialized back to file format?
+   - Are there any format-preserving mechanisms?
+
+6. **Identify special behaviors** by examining:
+
+   - Conditional logic specific to this bucket
+   - Error handling unique to this format
+   - Any validation or normalization steps
+   - Interactions between multiple loaders in the pipeline
+
+7. **Determine constraints and capabilities**:
+
+   - What data types/structures are supported?
+   - Are there any size or complexity limitations?
+   - What happens with edge cases (empty files, malformed content)?
+
+## Required Depth
+
+- Read the ACTUAL implementation of each loader/function
+- Follow all function calls to understand the complete flow
+- Don't make assumptions - verify behavior in the code
+- Consider the order of operations in the pipeline
+
+## Output Format
+
+List all findings categorized as:
+
+- Configuration parameters (with their types and defaults)
+- Processing pipeline (ordered list of transformations)
+- File handling behavior
+- Data transformation characteristics
+- Special capabilities or limitations
+- Edge case handling