/implement

Smart Implementation Engine

I'll intelligently implement features from any source - adapting them perfectly to your project's architecture while maintaining your code patterns and standards.

Arguments: `$ARGUMENTS` - URLs, paths, or descriptions of what to implement

Session Intelligence

I'll check for existing implementation sessions to continue seamlessly:

**Session Files (in current project directory):**

• `implement/plan.md` - Current implementation plan and progress
• `implement/state.json` - Session state and checkpoints

**IMPORTANT:** Session files are stored in a `implement` folder in your current project root, NOT in home directory or parent folders. If a session exists, I'll resume from the exact checkpoint. Otherwise, I'll create a new implementation plan and track progress throughout.

Phase 1: Initial Setup & Analysis

**MANDATORY FIRST STEPS:** 1. Check if `implement` directory exists in current working directory 2. If directory exists, check for session files:

• Look for `implement/state.json`
• Look for `implement/plan.md`
• If found, resume from existing session

3. If no directory or session exists:

• Create `implement/plan.md`
• Initialize `implement/state.json`

4. Complete full analysis BEFORE any implementation

**Critical:** Use `implement` folder in current directory. Do NOT use `$HOME/implement` or any parent directory paths

I'll examine what you've provided and your project structure:

**Source Detection:**

• Web URLs (GitHub, GitLab, CodePen, JSFiddle, documentation sites)
• Local paths (files, folders, existing code)
• Implementation plans (.md files with checklists)
• Feature descriptions for research

**Project Understanding:**

• Architecture patterns using **Glob** and **Read**
• Existing dependencies and their versions
• Code conventions and established patterns
• Testing approach and quality standards

Phase 2: Strategic Planning

Based on my analysis, I'll create an implementation plan:

**Plan Creation:**

• Map source features to your architecture
• Identify dependency compatibility
• Design integration approach
• Break work into testable chunks

I'll write this plan to `implement/plan.md`:

# Implementation Plan - [timestamp]

## Source Analysis
- **Source Type**: [URL/Local/Description]
- **Core Features**: [identified features to implement]
- **Dependencies**: [required libraries/frameworks]
- **Complexity**: [estimated effort]

## Target Integration
- **Integration Points**: [where it connects]
- **Affected Files**: [files to modify/create]
- **Pattern Matching**: [how to adapt to project style]

## Implementation Tasks
[Prioritized checklist with progress tracking]

## Validation Checklist
- [ ] All features implemented
- [ ] Tests written and passing
- [ ] No broken functionality
- [ ] Documentation updated
- [ ] Integration points verified
- [ ] Performance acceptable

## Risk Mitigation
- **Potential Issues**: [identified risks]
- **Rollback Strategy**: [git checkpoints]

Phase 3: Intelligent Adaptation

I'll transform the source to fit your project perfectly:

**Dependency Resolution:**

• Map source libraries to your existing ones
• Reuse your utilities instead of adding duplicates
• Convert patterns to match your codebase
• Update deprecated approaches to modern standards

**Code Transformation:**

• Match your naming conventions
• Follow your error handling patterns
• Maintain your state management approach
• Preserve your testing style

**Repository Analysis Strategy:** For large repositories, I'll use smart sampling:

• Core functionality first (main features, critical paths)
• Supporting code as needed
• Skip generated files, test data, documentation
• Focus on actual implementation code

Phase 4: Implementation Execution

I'll implement features incrementally:

**Execution Process:** 1. Implement core functionality 2. Add supporting utilities 3. Integrate with existing code 4. Update tests to cover new features 5. Validate everything works correctly

**Progress Tracking:**

• Update `implement/plan.md` as I complete each item
• Mark checkpoints in `implement/state.json`
• Create meaningful git commits at logical points

Phase 5: Quality Assurance

I'll ensure the implementation meets your standards:

**Validation Steps:**

• Run your existing lint commands
• Execute test suite
• Check for type errors
• Verify integration points
• Confirm no regressions

Deep Validation Process (All-in-One)

**ALL validation commands (`finish`, `verify`, `complete`, `enhance`) execute the SAME comprehensive process:**

When you run ANY of these: `/implement finish`, `/implement verify`, `/implement complete`, or `/implement enhance`

**I will AUTOMATICALLY:**

1. **Deep Original Source Analysis**

• Thoroughly analyze EVERY aspect of original code/requirements
• Study ALL implementation patterns and architectures
• Document COMPLETE functionality and business logic
• Map entire code structure and dependencies
• Create comprehensive analysis in `implement/source-analysis.md`

2. **Requirements Verification**

• Compare current implementation with original
• Map each original feature to new implementation
• Identify any missing features or behaviors
• Check edge cases from original code

3. **Comprehensive Testing**

• Write tests for ALL new code
• Run existing test suite
• Create integration tests
• Test error scenarios
• Verify performance requirements

4. **Deep Code Analysis**

• Check for incomplete TODOs
• Find hardcoded values to configure
• Verify error handling completeness
• Analyze security implications
• Check accessibility requirements

5. **Automatic Refinement**

• Fix any failing tests
• Complete partial implementations
• Add missing error handling
• Optimize performance bottlenecks
• Improve code documentation

6. **Integration Analysis**

• Analyze integration points thoroughly
• Verify API contracts match original