renamer/.specify/templates/tasks-template.md

description

description
Task list template for feature implementation

Tasks: [FEATURE NAME]

Input: Design documents from /specs/[###-feature-name]/ Prerequisites: plan.md (required), spec.md (required for user stories), research.md, data-model.md, contracts/

Tests: The examples below include test tasks. Tests are OPTIONAL - only include them if explicitly requested in the feature specification.

Organization: Tasks are grouped by user story to enable independent implementation and testing of each story.

Format: [ID] [P?] [Story] Description

• [P]: Can run in parallel (different files, no dependencies)
• [Story]: Which user story this task belongs to (e.g., US1, US2, US3)
• Include exact file paths in descriptions

Path Conventions

• Single project: src/, tests/ at repository root
• Web app: backend/src/, frontend/src/
• Mobile: api/src/, ios/src/ or android/src/
• Paths shown below assume single project - adjust based on plan.md structure

Phase 1: Setup (Shared Infrastructure)

Purpose: Project initialization and basic structure

• T001 Scaffold Cobra CLI command layout in cmd/ per implementation plan
• T002 Configure Go module dependencies (cobra, pflag) and shared config in go.mod
• T003 [P] Establish .renamer ledger helpers in internal/history/ledger.go

---

Phase 2: Foundational (Blocking Prerequisites)

Purpose: Core infrastructure that MUST be complete before ANY user story can be implemented

⚠️ CRITICAL: No user story work can begin until this phase is complete

Examples of foundational tasks (adjust based on your project):

• T004 Implement preview engine service in internal/preview/service.go
• T005 [P] Implement ledger append and undo mechanics in internal/history/undo.go
• T006 [P] Define rule interface and registry in internal/rules/registry.go
• T007 Create traversal utilities supporting -d, -r, and extension filtering in internal/traversal/walker.go
• T008 Configure structured logging and error handling for rename operations in internal/logging/logger.go
• T009 Document CLI flag contract and validation rules (including -e) in docs/cli-flags.md

Checkpoint: Foundation ready - user story implementation can now begin in parallel

---

Phase 3: User Story 1 - [Title] (Priority: P1) 🎯 MVP

Goal: [Brief description of what this story delivers]

Independent Test: [How to verify this story works on its own]

Tests for User Story 1 (OPTIONAL - only if tests requested) ⚠️

NOTE: Write these tests FIRST, ensure they FAIL before implementation

• T010 [P] [US1] CLI preview contract test (covers extension filters) in tests/contract/preview_test.go
• T011 [P] [US1] Integration test covering preview confirmation flow in tests/integration/preview_flow_test.go

Implementation for User Story 1

• T012 [P] [US1] Implement default rename rule in internal/rules/default.go
• T013 [P] [US1] Implement extension filter parsing and validation in internal/filters/extensions.go
• T014 [US1] Implement preview renderer in internal/preview/format.go
• T015 [US1] Wire Cobra command to preview service and filters in cmd/root.go (depends on T012, T013, T014)
• T016 [US1] Add confirmation prompt and dry-run guardrails in cmd/root.go
• T017 [US1] Harden validation and conflict detection (including filter edge cases) in internal/preview/validate.go
• T018 [US1] Emit structured preview logs in internal/logging/logger.go

Checkpoint: At this point, User Story 1 should be fully functional and testable independently

---

Phase 4: User Story 2 - [Title] (Priority: P2)

Goal: [Brief description of what this story delivers]

Independent Test: [How to verify this story works on its own]

Tests for User Story 2 (OPTIONAL - only if tests requested) ⚠️

• T019 [P] [US2] Ledger append/undo contract test in tests/contract/ledger_test.go
• T020 [P] [US2] Integration test for undo workflow in tests/integration/undo_flow_test.go

Implementation for User Story 2

• T021 [P] [US2] Create ledger persistence adapter in internal/history/storage.go
• T022 [US2] Implement undo command wiring in cmd/undo.go
• T023 [US2] Guard undo execution with validation in internal/history/validate.go
• T024 [US2] Reuse preview output to display revert plan prior to undo

Checkpoint: At this point, User Stories 1 AND 2 should both work independently

---

Phase 5: User Story 3 - [Title] (Priority: P3)

Goal: [Brief description of what this story delivers]

Independent Test: [How to verify this story works on its own]

Tests for User Story 3 (OPTIONAL - only if tests requested) ⚠️

• T025 [P] [US3] Recursion traversal contract test in tests/contract/traversal_test.go
• T026 [P] [US3] Integration test for nested directory rename in tests/integration/traversal_flow_test.go

Implementation for User Story 3

• T027 [P] [US3] Extend traversal walker to honor include/exclude patterns in internal/traversal/filter.go
• T028 [US3] Implement directory rename rule enabling -d support in internal/rules/directories.go
• T029 [US3] Update CLI to surface traversal options and help text in cmd/root.go

Checkpoint: All user stories should now be independently functional

---

[Add more user story phases as needed, following the same pattern]

---

Phase N: Polish & Cross-Cutting Concerns

Purpose: Improvements that affect multiple user stories

• TXXX [P] Documentation updates in docs/
• TXXX Code cleanup and refactoring
• TXXX Performance optimization across all stories
• TXXX [P] Additional unit tests (if requested) in tests/unit/
• TXXX Security hardening
• TXXX Run quickstart.md validation

---

Dependencies & Execution Order

Phase Dependencies

• Setup (Phase 1): No dependencies - can start immediately
• Foundational (Phase 2): Depends on Setup completion - BLOCKS all user stories
• User Stories (Phase 3+): All depend on Foundational phase completion
  • User stories can then proceed in parallel (if staffed)
  • Or sequentially in priority order (P1 → P2 → P3)
• Polish (Final Phase): Depends on all desired user stories being complete

User Story Dependencies

• User Story 1 (P1): Can start after Foundational (Phase 2) - No dependencies on other stories
• User Story 2 (P2): Can start after Foundational (Phase 2) - May integrate with US1 but should be independently testable
• User Story 3 (P3): Can start after Foundational (Phase 2) - May integrate with US1/US2 but should be independently testable

Within Each User Story

• Tests (if included) MUST be written and FAIL before implementation
• Models before services
• Services before endpoints
• Core implementation before integration
• Story complete before moving to next priority

Parallel Opportunities

• All Setup tasks marked [P] can run in parallel
• All Foundational tasks marked [P] can run in parallel (within Phase 2)
• Once Foundational phase completes, all user stories can start in parallel (if team capacity allows)
• All tests for a user story marked [P] can run in parallel
• Models within a story marked [P] can run in parallel
• Different user stories can be worked on in parallel by different team members

---

Parallel Example: User Story 1

# Launch all tests for User Story 1 together (if tests requested):
Task: "Contract test for [endpoint] in tests/contract/test_[name].py"
Task: "Integration test for [user journey] in tests/integration/test_[name].py"

# Launch all models for User Story 1 together:
Task: "Create [Entity1] model in src/models/[entity1].py"
Task: "Create [Entity2] model in src/models/[entity2].py"

---

Implementation Strategy

MVP First (User Story 1 Only)

1. Complete Phase 1: Setup
2. Complete Phase 2: Foundational (CRITICAL - blocks all stories)
3. Complete Phase 3: User Story 1
4. STOP and VALIDATE: Test User Story 1 independently
5. Deploy/demo if ready

Incremental Delivery

1. Complete Setup + Foundational → Foundation ready
2. Add User Story 1 → Test independently → Deploy/Demo (MVP!)
3. Add User Story 2 → Test independently → Deploy/Demo
4. Add User Story 3 → Test independently → Deploy/Demo
5. Each story adds value without breaking previous stories

Parallel Team Strategy

With multiple developers:

1. Team completes Setup + Foundational together
2. Once Foundational is done:
   • Developer A: User Story 1
   • Developer B: User Story 2
   • Developer C: User Story 3
3. Stories complete and integrate independently

---

Notes

• [P] tasks = different files, no dependencies
• [Story] label maps task to specific user story for traceability
• Each user story should be independently completable and testable
• Verify tests fail before implementing
• Commit after each task or logical group
• Stop at any checkpoint to validate story independently
• Avoid: vague tasks, same file conflicts, cross-story dependencies that break independence