Neohaskell Feature Pipeline

Pipeline Phases

Workflow

1. Initialize: Run pipeline.py init with feature details
2. Get Next Phase: Run pipeline.py next for phase info and prompts
3. Execute Phase: Follow the phase instructions or delegate to appropriate agent
4. Complete Phase: Run pipeline.py complete N
5. Handle PAUSE Gates: Wait for maintainer to run pipeline.py approve N
6. Repeat: Continue until pipeline returns {"status": "complete"}

Variables

Set these before starting:

Find next ADR number:

ls docs/decisions/*.md | tail -1

Phase Details

Phase 1: ADR Draft

Create the Architecture Decision Record at docs/decisions/NNNN-slug.md.

Requirements:

• Follow ADR template exactly (read neohaskell-adr-template skill)
• Include type definitions, module placement, public API
• All code examples must follow NeoHaskell style guide
• Reference the GitHub issue
• Set Status: Proposed

PAUSE after: Report ADR path to maintainer for review.

Phases 2-3: Security & Performance Review (ADR)

Can run in parallel. Read-only analysis of the ADR.

Security Review (Phase 2):

• Evaluate against OWASP Top 10, NIST controls, EU/GDPR
• Rate findings: Critical/High/Medium/Low/None
• Any Critical/High finding blocks pipeline

Performance Review (Phase 3):

• Evaluate serialization impact, hot path placement
• Check memory characteristics, allocation patterns
• Target: 50k req/s maintained

Phase 4: DevEx Review

Evaluate API quality:

• Intuitiveness and naming
• Pipe-friendliness
• Discoverability
• Consistency with existing nhcore patterns

PAUSE after: Report pass/fail count to maintainer.

Phase 5: Architecture Design

Create detailed architecture document:

• Module placement map
• Public API signatures with full type definitions
• Integration points with existing nhcore
• Dependency map

PAUSE after: Report architecture to maintainer.

Phase 6: Test Spec Design

Design comprehensive test specification (outside-in TDD entry point):

• Read architecture document for public API
• Match patterns from existing tests (DecimalSpec.hs, RedactedSpec.hs)
• Cover: happy paths, edge cases, error conditions, serialization, properties
• Minimum 3 test cases per public function
• Target 3:1 edge-to-happy ratio

PAUSE after: Report test count summary to maintainer.

Phase 7: Test Suite Writing

Translate test spec to Haskell test code:

• Each row in spec = one it block
• Tests must compile but ALL fail (no implementation yet)
• Register in cabal file and test runner
• Do NOT add tests beyond the spec

Phases 8-9: Implementation & Build Loop

Implement the feature and iterate until green:

• Follow architecture document precisely
• Use NeoHaskell style: pipes, do-blocks, case expressions
• Run cabal build all && cabal test
• Run hlint on changed files
• Max 10 iterations; escalate if still failing

Phases 10-11: Security & Performance Review (Impl)

Can run in parallel. Code-level reviews with file:line references.

Security Review (Phase 10):

• Input validation, injection vectors
• Overflow/bounds handling
• Information disclosure in errors

Performance Review (Phase 11):

• INLINE pragmas placement
• Strict field annotations
• toEncoding vs toJSON for serialization
• SPECIALIZE pragmas for polymorphic hot paths

PAUSE after each: Report findings to maintainer.

Phase 12: Fix Review Notes

Apply all security and performance fixes. If files changed significantly, re-trigger relevant reviews.

Phase 13: Final Build & Test

Final verification:

• cabal build all succeeds
• All test suites pass
• hlint . clean on changed files

Phase 14: Create PR

1. Write PR body with summary, changes list, checklist
2. Include Closes #ISSUE_NUMBER
3. Create branch, commit, push
4. Create PR via gh pr create

PAUSE after: Report PR URL to maintainer.

Phases 15-16: Bot Review & Fixes

Wait for CI, then address any CodeRabbit or CI comments:

gh pr checks PR_NUMBER --watch
gh api repos/neohaskell/NeoHaskell/pulls/PR_NUMBER/comments

Phase 17: Final Approval

Human gate. Maintainer reviews, approves, and merges the PR.

Parallel Execution

These phases can run simultaneously:

• Phases 2 + 3 (Security + Performance ADR reviews)
• Phases 10 + 11 (Security + Performance implementation reviews)

Failure Recovery

Deliverables Checklist

At completion, verify:

• ADR: docs/decisions/NNNN-slug.md
• Source module at MODULE_PATH
• Test file at TEST_PATH
• All tests passing
• hlint clean
• No Critical/High security findings
• 50k req/s target maintained
• PR ready for review
• nhcore.cabal updated with new modules

Related Skills

• neohaskell-adr-template - ADR format and structure
• neohaskell-style-guide - Code style conventions