data_porter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfa4a171b2ca5f54f539d74f14abd600159aa8563924d8c83c9b7d4a00f5e1ff
+  data.tar.gz: 3f0f50d55471aa7fc3b888a8b2472d29c93af7559702f6f3c84fb180aa40f5aa
+SHA512:
+  metadata.gz: 2624e1366152820ae9070e607f2ad88cb6ce4e65c4fedaeb193ec116c5155879a6ce7be5f55a2d5f7b20a8a96308cb0f5d7e57535bbabe4a726ed62e3374abac
+  data.tar.gz: 2b03913652f0a6a47a62396174c5be712c3825b570b52b8c58baa715632d99b16d4e3d1bb8df50289f81ad15ce2389640ff87542ece3a2eeedf980273f6f4f69

data/.claude/commands/blog-status.md

@@ -0,0 +1,10 @@
+Show the status of the DataPorter blog article series.
+
+1. List all existing articles in `docs/blog/` with their title, part number, and published status
+2. Check `task-master list` for completed tasks since the last article
+3. Suggest 2-3 potential next article topics based on:
+   - Recently completed tasks not yet covered
+   - The natural progression of the series
+   - Topics that would be interesting for the Ruby/Rails community
+
+Format the output as a clear dashboard.

data/.claude/commands/blog.md

@@ -0,0 +1,109 @@
+Write the next blog article for the DataPorter series.
+
+Topic/title hint: $ARGUMENTS
+
+## Process
+
+1. **Read the series plan** at `docs/blog/SERIES.md` to identify which part this is and what it should cover.
+
+2. **Gather context:**
+   - `task-master list` to see completed tasks
+   - `git log --oneline -20` for recent commits
+   - Read the source files listed in the series plan for this part
+   - Read any previous articles in `docs/blog/` to maintain continuity
+
+3. **Write the article** in `docs/blog/NNN-slug.md` (NNN = part number, zero-padded).
+
+4. **Mandatory article structure:**
+
+```markdown
+---
+title: "Building DataPorter #N — <Title>"
+series: "Building DataPorter - A Data Import Engine for Rails"
+part: N
+tags: [ruby, rails, rails-engine, gem-development, <2-3 topic tags>]
+published: false
+---
+
+# <Title>
+
+> One-line summary of what the reader will learn.
+
+## Context
+
+Where we are in the series (1-2 sentences). Link to previous article.
+What we'll build in this article (clear scope).
+
+## The problem
+
+Why do we need this? Real-world scenario. Keep it short (3-5 sentences).
+
+## What we're building
+
+Show the end result first: a code snippet, a diagram, or a usage example.
+The reader should immediately understand where we're going.
+
+## Implementation
+
+### Step 1 — <Name>
+
+Explain the WHY, then show the code.
+
+\`\`\`ruby
+# path/to/file.rb
+<focused snippet, not full file>
+\`\`\`
+
+Brief explanation of what this does and why we chose this approach.
+
+### Step 2 — <Name>
+
+(repeat pattern: WHY -> code -> explain)
+
+### Step 3 — <Name>
+
+(repeat)
+
+## Decisions & tradeoffs
+
+| Decision | We chose | Over | Because |
+|----------|----------|------|---------|
+| ... | ... | ... | ... |
+
+## Testing it
+
+Show how to verify this works (spec snippet or console output).
+
+\`\`\`ruby
+# spec/...
+\`\`\`
+
+## Recap
+
+3-4 bullet points: what we built, what we learned.
+
+## Next up
+
+One paragraph teasing the next article in the series. End with a hook.
+
+---
+
+*This is part N of the series "Building DataPorter". [Previous: ...](#) | [Next: ...](#)*
+*Code: [GitHub repo link]*
+```
+
+5. **Writing rules:**
+   - 5-8 minute read (~1000-1500 words)
+   - Max 3-4 implementation steps per article
+   - Code snippets: focused, 5-25 lines each (never full file dumps)
+   - Every snippet has a file path comment on line 1
+   - Explain decisions as "We chose X over Y because Z"
+   - Use the actual code from the codebase (not made-up examples)
+   - Conversational but technical tone: "Let's...", "Here's why..."
+   - English only
+   - No emojis in prose (OK in front matter tags)
+
+6. **After writing:**
+   - Update the article status in `docs/blog/SERIES.md` to `draft`
+   - Show: title, word count, reading time, and the decisions table
+   - Suggest 2-3 improvements or missing points

data/.claude/commands/task-done.md

@@ -0,0 +1,27 @@
+Mark a Taskmaster task as done and check if a blog article should be generated.
+
+Task ID: $ARGUMENTS
+
+## Process
+
+1. **Complete the task:**
+   ```
+   task-master set-status --id=$ARGUMENTS --status=done
+   ```
+
+2. **Check blog series:** Read `docs/blog/SERIES.md` and find which blog part includes this task.
+
+3. **Check if all tasks for that part are done:**
+   - Run `task-master show <id>` for each task in the blog part
+   - If ALL tasks for the part have status `done`, proceed to step 4
+   - If some tasks are still pending/in-progress, report progress ("Part N: 2/3 tasks done")
+
+4. **If part is ready, generate the article:**
+   - Follow the `/blog` command process
+   - Write the draft in `docs/blog/NNN-slug.md`
+   - Update SERIES.md status to `draft`
+
+5. **Show summary:**
+   - Task completed
+   - Blog part progress (e.g., "Part 5: 2/2 tasks done — article draft generated")
+   - Next task suggestion via `task-master next`

data/.claude/commands/tm/add-dependency.md

@@ -0,0 +1,58 @@
+Add Dependency
+
+Arguments: $ARGUMENTS
+Add a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to establish dependency relationship.
+
+## Adding Dependencies
+
+Creates a dependency where one task must be completed before another can start.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "make 5 depend on 3" → task 5 depends on task 3
+- "5 needs 3" → task 5 depends on task 3
+- "5 3" → task 5 depends on task 3
+- "5 after 3" → task 5 depends on task 3
+
+## Execution
+
+```bash
+task-master add-dependency --id=<task-id> --depends-on=<dependency-id>
+```
+
+## Validation
+
+Before adding:
+1. **Verify both tasks exist**
+2. **Check for circular dependencies**
+3. **Ensure dependency makes logical sense**
+4. **Warn if creating complex chains**
+
+## Smart Features
+
+- Detect if dependency already exists
+- Suggest related dependencies
+- Show impact on task flow
+- Update task priorities if needed
+
+## Post-Addition
+
+After adding dependency:
+1. Show updated dependency graph
+2. Identify any newly blocked tasks
+3. Suggest task order changes
+4. Update project timeline
+
+## Example Flows
+
+```
+/taskmaster:add-dependency 5 needs 3
+→ Task #5 now depends on Task #3
+→ Task #5 is now blocked until #3 completes
+→ Suggested: Also consider if #5 needs #4
+```

data/.claude/commands/tm/add-subtask.md

@@ -0,0 +1,79 @@
+Add Subtask
+
+Arguments: $ARGUMENTS
+Add a subtask to a parent task.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to create a new subtask or convert existing task.
+
+## Adding Subtasks
+
+Creates subtasks to break down complex parent tasks into manageable pieces.
+
+## Argument Parsing
+
+Flexible natural language:
+- "add subtask to 5: implement login form"
+- "break down 5 with: setup, implement, test"
+- "subtask for 5: handle edge cases"
+- "5: validate user input" → adds subtask to task 5
+
+## Execution Modes
+
+### 1. Create New Subtask
+```bash
+task-master add-subtask --parent=<id> --title="<title>" --description="<desc>"
+```
+
+### 2. Convert Existing Task
+```bash
+task-master add-subtask --parent=<id> --task-id=<existing-id>
+```
+
+## Smart Features
+
+1. **Automatic Subtask Generation**
+   - If title contains "and" or commas, create multiple
+   - Suggest common subtask patterns
+   - Inherit parent's context
+
+2. **Intelligent Defaults**
+   - Priority based on parent
+   - Appropriate time estimates
+   - Logical dependencies between subtasks
+
+3. **Validation**
+   - Check parent task complexity
+   - Warn if too many subtasks
+   - Ensure subtask makes sense
+
+## Creation Process
+
+1. Parse parent task context
+2. Generate subtask with ID like "5.1"
+3. Set appropriate defaults
+4. Link to parent task
+5. Update parent's time estimate
+
+## Example Flows
+
+```
+/taskmaster:add-subtask to 5: implement user authentication
+→ Created subtask #5.1: "implement user authentication"
+→ Parent task #5 now has 1 subtask
+→ Suggested next subtasks: tests, documentation
+
+/taskmaster:add-subtask 5: setup, implement, test
+→ Created 3 subtasks:
+  #5.1: setup
+  #5.2: implement
+  #5.3: test
+```
+
+## Post-Creation
+
+- Show updated task hierarchy
+- Suggest logical next subtasks
+- Update complexity estimates
+- Recommend subtask order

data/.claude/commands/tm/add-task.md

@@ -0,0 +1,81 @@
+Add Task
+
+Arguments: $ARGUMENTS
+Add new tasks with intelligent parsing and context awareness.
+
+Arguments: $ARGUMENTS
+
+## Smart Task Addition
+
+Parse natural language to create well-structured tasks.
+
+### 1. **Input Understanding**
+
+I'll intelligently parse your request:
+- Natural language → Structured task
+- Detect priority from keywords (urgent, ASAP, important)
+- Infer dependencies from context
+- Suggest complexity based on description
+- Determine task type (feature, bug, refactor, test, docs)
+
+### 2. **Smart Parsing Examples**
+
+**"Add urgent task to fix login bug"**
+→ Title: Fix login bug
+→ Priority: high
+→ Type: bug
+→ Suggested complexity: medium
+
+**"Create task for API documentation after task 23 is done"**
+→ Title: API documentation
+→ Dependencies: [23]
+→ Type: documentation
+→ Priority: medium
+
+**"Need to refactor auth module - depends on 12 and 15, high complexity"**
+→ Title: Refactor auth module
+→ Dependencies: [12, 15]
+→ Complexity: high
+→ Type: refactor
+
+### 3. **Context Enhancement**
+
+Based on current project state:
+- Suggest related existing tasks
+- Warn about potential conflicts
+- Recommend dependencies
+- Propose subtasks if complex
+
+### 4. **Interactive Refinement**
+
+```yaml
+Task Preview:
+─────────────
+Title: [Extracted title]
+Priority: [Inferred priority]
+Dependencies: [Detected dependencies]
+Complexity: [Estimated complexity]
+
+Suggestions:
+- Similar task #34 exists, consider as dependency?
+- This seems complex, break into subtasks?
+- Tasks #45-47 work on same module
+```
+
+### 5. **Validation & Creation**
+
+Before creating:
+- Validate dependencies exist
+- Check for duplicates
+- Ensure logical ordering
+- Verify task completeness
+
+### 6. **Smart Defaults**
+
+Intelligent defaults based on:
+- Task type patterns
+- Team conventions
+- Historical data
+- Current sprint/phase
+
+Result: High-quality tasks from minimal input.

data/.claude/commands/tm/analyze-complexity.md

@@ -0,0 +1,124 @@
+Analyze Complexity
+
+Arguments: $ARGUMENTS
+Analyze task complexity and generate expansion recommendations.
+
+Arguments: $ARGUMENTS
+
+Perform deep analysis of task complexity across the project.
+
+## Complexity Analysis
+
+Uses AI to analyze tasks and recommend which ones need breakdown.
+
+## Execution Options
+
+```bash
+task-master analyze-complexity [--research] [--threshold=5]
+```
+
+## Analysis Parameters
+
+- `--research` → Use research AI for deeper analysis
+- `--threshold=5` → Only flag tasks above complexity 5
+- Default: Analyze all pending tasks
+
+## Analysis Process
+
+### 1. **Task Evaluation**
+For each task, AI evaluates:
+- Technical complexity
+- Time requirements
+- Dependency complexity
+- Risk factors
+- Knowledge requirements
+
+### 2. **Complexity Scoring**
+Assigns score 1-10 based on:
+- Implementation difficulty
+- Integration challenges
+- Testing requirements
+- Unknown factors
+- Technical debt risk
+
+### 3. **Recommendations**
+For complex tasks:
+- Suggest expansion approach
+- Recommend subtask breakdown
+- Identify risk areas
+- Propose mitigation strategies
+
+## Smart Analysis Features
+
+1. **Pattern Recognition**
+   - Similar task comparisons
+   - Historical complexity accuracy
+   - Team velocity consideration
+   - Technology stack factors
+
+2. **Contextual Factors**
+   - Team expertise
+   - Available resources
+   - Timeline constraints
+   - Business criticality
+
+3. **Risk Assessment**
+   - Technical risks
+   - Timeline risks
+   - Dependency risks
+   - Knowledge gaps
+
+## Output Format
+
+```
+Task Complexity Analysis Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+High Complexity Tasks (>7):
+📍 #5 "Implement real-time sync" - Score: 9/10
+   Factors: WebSocket complexity, state management, conflict resolution
+   Recommendation: Expand into 5-7 subtasks
+   Risks: Performance, data consistency
+
+📍 #12 "Migrate database schema" - Score: 8/10
+   Factors: Data migration, zero downtime, rollback strategy
+   Recommendation: Expand into 4-5 subtasks
+   Risks: Data loss, downtime
+
+Medium Complexity Tasks (5-7):
+📍 #23 "Add export functionality" - Score: 6/10
+   Consider expansion if timeline tight
+
+Low Complexity Tasks (<5):
+✅ 15 tasks - No expansion needed
+
+Summary:
+- Expand immediately: 2 tasks
+- Consider expanding: 5 tasks
+- Keep as-is: 15 tasks
+```
+
+## Actionable Output
+
+For each high-complexity task:
+1. Complexity score with reasoning
+2. Specific expansion suggestions
+3. Risk mitigation approaches
+4. Recommended subtask structure
+
+## Integration
+
+Results are:
+- Saved to `.taskmaster/reports/complexity-analysis.md`
+- Used by expand command
+- Inform sprint planning
+- Guide resource allocation
+
+## Next Steps
+
+After analysis:
+```
+/taskmaster:expand 5    # Expand specific task
+/taskmaster:expand-all  # Expand all recommended
+/taskmaster:complexity-report  # View detailed report
+```

data/.claude/commands/tm/analyze-project.md

@@ -0,0 +1,100 @@
+Analyze Project
+
+Arguments: $ARGUMENTS
+Advanced project analysis with actionable insights and recommendations.
+
+Arguments: $ARGUMENTS
+
+## Comprehensive Project Analysis
+
+Multi-dimensional analysis based on requested focus area.
+
+### 1. **Analysis Modes**
+
+Based on $ARGUMENTS:
+- "velocity" → Sprint velocity and trends
+- "quality" → Code quality metrics
+- "risk" → Risk assessment and mitigation
+- "dependencies" → Dependency graph analysis
+- "team" → Workload and skill distribution
+- "architecture" → System design coherence
+- Default → Full spectrum analysis
+
+### 2. **Velocity Analytics**
+
+```
+📊 Velocity Analysis
+━━━━━━━━━━━━━━━━━━━
+Current Sprint: 24 points/week ↗️ +20%
+Rolling Average: 20 points/week
+Efficiency: 85% (17/20 tasks on time)
+
+Bottlenecks Detected:
+- Code review delays (avg 4h wait)
+- Test environment availability
+- Dependency on external team
+
+Recommendations:
+1. Implement parallel review process
+2. Add staging environment
+3. Mock external dependencies
+```
+
+### 3. **Risk Assessment**
+
+**Technical Risks**
+- High complexity tasks without backup assignee
+- Single points of failure in architecture
+- Insufficient test coverage in critical paths
+- Technical debt accumulation rate
+
+**Project Risks**
+- Critical path dependencies
+- Resource availability gaps
+- Deadline feasibility analysis
+- Scope creep indicators
+
+### 4. **Dependency Intelligence**
+
+Visual dependency analysis:
+```
+Critical Path:
+#12 → #15 → #23 → #45 → #50 (20 days)
+         ↘ #24 → #46 ↗
+
+Optimization: Parallelize #15 and #24
+Time Saved: 3 days
+```
+
+### 5. **Quality Metrics**
+
+**Code Quality**
+- Test coverage trends
+- Complexity scores
+- Technical debt ratio
+- Review feedback patterns
+
+**Process Quality**
+- Rework frequency
+- Bug introduction rate
+- Time to resolution
+- Knowledge distribution
+
+### 6. **Predictive Insights**
+
+Based on patterns:
+- Completion probability by deadline
+- Resource needs projection
+- Risk materialization likelihood
+- Suggested interventions
+
+### 7. **Executive Dashboard**
+
+High-level summary with:
+- Health score (0-100)
+- Top 3 risks
+- Top 3 opportunities
+- Recommended actions
+- Success probability
+
+Result: Data-driven decisions with clear action paths.

data/.claude/commands/tm/auto-implement-tasks.md

@@ -0,0 +1,100 @@
+Auto Implement Tasks
+
+Arguments: $ARGUMENTS
+Enhanced auto-implementation with intelligent code generation and testing.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Auto-Implementation
+
+Advanced implementation with context awareness and quality checks.
+
+### 1. **Pre-Implementation Analysis**
+
+Before starting:
+- Analyze task complexity and requirements
+- Check codebase patterns and conventions
+- Identify similar completed tasks
+- Assess test coverage needs
+- Detect potential risks
+
+### 2. **Smart Implementation Strategy**
+
+Based on task type and context:
+
+**Feature Tasks**
+1. Research existing patterns
+2. Design component architecture
+3. Implement with tests
+4. Integrate with system
+5. Update documentation
+
+**Bug Fix Tasks**
+1. Reproduce issue
+2. Identify root cause
+3. Implement minimal fix
+4. Add regression tests
+5. Verify side effects
+
+**Refactoring Tasks**
+1. Analyze current structure
+2. Plan incremental changes
+3. Maintain test coverage
+4. Refactor step-by-step
+5. Verify behavior unchanged
+
+### 3. **Code Intelligence**
+
+**Pattern Recognition**
+- Learn from existing code
+- Follow team conventions
+- Use preferred libraries
+- Match style guidelines
+
+**Test-Driven Approach**
+- Write tests first when possible
+- Ensure comprehensive coverage
+- Include edge cases
+- Performance considerations
+
+### 4. **Progressive Implementation**
+
+Step-by-step with validation:
+```
+Step 1/5: Setting up component structure ✓
+Step 2/5: Implementing core logic ✓
+Step 3/5: Adding error handling ⚡ (in progress)
+Step 4/5: Writing tests ⏳
+Step 5/5: Integration testing ⏳
+
+Current: Adding try-catch blocks and validation...
+```
+
+### 5. **Quality Assurance**
+
+Automated checks:
+- Linting and formatting
+- Test execution
+- Type checking
+- Dependency validation
+- Performance analysis
+
+### 6. **Smart Recovery**
+
+If issues arise:
+- Diagnostic analysis
+- Suggestion generation
+- Fallback strategies
+- Manual intervention points
+- Learning from failures
+
+### 7. **Post-Implementation**
+
+After completion:
+- Generate PR description
+- Update documentation
+- Log lessons learned
+- Suggest follow-up tasks
+- Update task relationships
+
+Result: High-quality, production-ready implementations.