pi-pipelines 0.1.0

package/pipelines/dev-sprint.pipeline.yaml

@@ -0,0 +1,104 @@
+name: dev-sprint
+description: "Complete development cycle: plan → TDD with review gates → test → project review and next actions."
+report:
+  agent: planner
+  focus: "development cycle outcomes, current project state, and next actions"
+
+
+stages:
+  - id: plan
+    agent: planner
+    task: >
+      Analyze the codebase and create a detailed implementation plan for: {task}.
+      Include acceptance criteria, test strategy, architecture decisions,
+      likely files to change, dependencies, risks, and verification plan.
+      If the task is ambiguous, state what needs clarification.
+
+  - id: write-tests
+    agent: worker
+    task: >
+      Write comprehensive tests for: {task}.
+      Follow the plan: {outputs.plan}.
+      Use the project's test framework and conventions.
+      Cover: happy paths, error paths, edge cases, integration points.
+      Do not modify production code in this stage.
+
+    gate:
+      type: review-loop
+      maxRounds: 3
+      targetScore: 9
+      reviewers:
+        - focus: "Test completeness: are all scenarios, acceptance criteria, and edge cases from the plan covered?"
+        - focus: "Test quality: are tests isolated, deterministic, maintainable, and following project conventions?"
+        - focus: "Edge cases: are boundary values, error states, unusual inputs, and integration points tested where relevant?"
+
+  - id: implement
+    agent: worker
+    task: >
+      Implement the code to pass the tests: {outputs.write-tests}.
+      Follow the plan: {outputs.plan}.
+      Keep code clean, focused, and well-structured.
+      Do not modify tests unless a test is clearly invalid; if you modify a test, explain why.
+
+    gate:
+      type: review-loop
+      maxRounds: 3
+      targetScore: 8
+      reviewers:
+        - focus: "Does the implementation satisfy ALL acceptance criteria and make the intended tests pass?"
+        - focus: "Is the code simple, readable, maintainable, and consistent with existing project patterns?"
+        - focus: "Does the implementation handle errors and edge cases without overengineering?"
+
+  - id: verify
+    agent: worker
+    task: >
+      Run the full project test suite using the existing package manager or test scripts.
+      Report:
+      - Pass/fail counts
+      - Any regressions
+      - Coverage if available
+      - Commands attempted and blockers
+      - Stability assessment
+      Implementation context: {outputs.implement}
+
+  - id: project-review
+    parallel:
+      - id: code-health
+        agent: oracle
+        task: >
+          Review the overall project state after this change for: {task}.
+          Consider the verification results: {outputs.verify}.
+          What technical debt exists? What should be addressed soon?
+          Return concise sections: Debt, Soon, Risks.
+
+      - id: next-priorities
+        agent: planner
+        task: >
+          Based on the project state, verification results: {outputs.verify},
+          and this work, what are the 3 most impactful things to work on next for: {task}?
+          Prioritize by user value, risk reduction, and maintainability.
+          Return exactly 3 prioritized next tasks with rationale.
+
+      - id: quality-assessment
+        agent: reviewer
+        task: >
+          Assess the overall quality of the project implementation for: {task}.
+          Consider the verification results: {outputs.verify}.
+          What risks, bottlenecks, or areas need attention before continuing?
+          Return a concise quality/risk report.
+
+  - id: synthesize
+    agent: planner
+    task: >
+      Synthesize the project review findings into a clear action plan.
+
+      Code Health: {outputs.code-health}
+      Next Priorities: {outputs.next-priorities}
+      Quality Assessment: {outputs.quality-assessment}
+      Verification Results: {outputs.verify}
+
+      Output a structured proposal with:
+      1. What was accomplished
+      2. Current project state
+      3. Top 3 recommended next tasks with rationale
+      4. Any blocking issues or risks

package/pipelines/hello-world.pipeline.yaml

@@ -0,0 +1,25 @@
+name: hello-world
+description: "Smoke-test pipeline: explore relevant project areas, then produce a concise action plan."
+report:
+  agent: planner
+  focus: "quick overview and recommended next action"
+
+
+stages:
+  - id: explore
+    agent: scout
+    task: >
+      Explore the codebase for: {task}.
+      Return a concise structured summary with:
+      1. Relevant files and directories
+      2. Likely tech stack and test commands
+      3. Obvious risks, assumptions, or missing context
+      If the task is too broad, say what needs clarification.
+
+  - id: plan
+    agent: planner
+    task: >
+      Based on this exploration: {outputs.explore},
+      create a simple action plan for: {task}.
+      Keep it concise — 3-5 bullet points.
+      Include: next action, likely files to change, and verification step.

package/pipelines/refactor.pipeline.yaml

@@ -0,0 +1,59 @@
+name: refactor
+description: "Safe refactoring pipeline — understand, plan, refactor with review gate, verify no regressions."
+report:
+  agent: planner
+  focus: "refactoring results, regression risk, and next steps"
+
+
+stages:
+  - id: understand
+    agent: scout
+    task: >
+      Analyze the codebase to understand the current state of: {task}.
+      Find all relevant files, data flow, dependencies, and existing tests.
+      Identify risks, unknowns, and safe refactoring boundaries.
+      Return a concise map of what should and should not be changed.
+
+  - id: plan
+    agent: planner
+    task: >
+      Create a refactoring plan for: {task}.
+      Based on the codebase analysis: {outputs.understand}.
+      Include:
+      - Files to change
+      - Order of changes (to avoid breaking state)
+      - Test strategy
+      - Rollback plan
+      - Risk mitigation steps
+
+  - id: refactor
+    agent: worker
+    task: >
+      Implement the refactoring according to this plan: {outputs.plan}.
+      Codebase context: {outputs.understand}.
+      Make incremental, verifiable changes.
+      Preserve behavior; do not add unrelated features.
+      If tests reveal a behavior mismatch, stop and report it clearly.
+
+    gate:
+      type: review-loop
+      maxRounds: 3
+      targetScore: 8
+      reviewers:
+        - focus: "Does the refactored code preserve the original behavior? Are there behavior changes or missing cases?"
+        - focus: "Is the refactored code simpler, cleaner, and easier to maintain without unnecessary changes?"
+        - focus: "Are there any breaking changes, regressions, or risky edits that should block this refactor?"
+
+  - id: verify
+    agent: worker
+    task: >
+      Run the full test suite to verify no regressions after refactoring: {outputs.refactor}.
+      Report any failures, flaky tests, coverage impact if available, and commands attempted.
+
+  - id: summary
+    agent: planner
+    task: >
+      Summarize the refactoring done for: {task}.
+      Explain what changed, why it improved the codebase, and any follow-up work needed.
+      Test results: {outputs.verify}.
+      Include changed files if they are known from the refactor output.

package/pipelines/release-check.pipeline.yaml

@@ -0,0 +1,60 @@
+name: release-check
+description: "Pre-release quality gate — parallel code review, security audit, stability verification, and readiness decision."
+report:
+  agent: scout
+  focus: "release readiness assessment and blocked issues"
+
+
+stages:
+  - id: checks
+    parallel:
+      - id: code-review
+        agent: reviewer
+        task: >
+          Perform a thorough code review of recent changes for: {task}.
+          Check for bugs, correctness, readability, architecture fit, error handling,
+          test coverage, and adherence to project standards.
+          Return a concise report starting with `### Code Review`:
+          findings, severity, affected files, and recommended fixes.
+
+      - id: security-audit
+        agent: reviewer
+        task: >
+          Security audit focused on: {task}.
+          Check for:
+          - Injection vulnerabilities
+          - Authentication/authorization issues
+          - Sensitive data exposure
+          - Dependency vulnerabilities
+          - Unsafe code patterns
+          Return a concise report starting with `### Security Audit`:
+          vulnerabilities, severity, evidence, and remediation priority.
+
+      - id: stability-check
+        agent: worker
+        task: >
+          Run the full project test suite using the existing package manager or test scripts.
+          Report:
+          - Total tests passed/failed
+          - Any flaky or slow tests
+          - Test duration
+          - Code coverage if available
+          - Commands attempted and blockers
+          Project context: {task}
+          Return a concise report starting with `### Stability Check`.
+
+  - id: release-readiness
+    agent: reviewer
+    task: >
+      Based on the following reports, assess overall release readiness for: {task}.
+
+      Code Review: {outputs.code-review}
+      Security Audit: {outputs.security-audit}
+      Stability: {outputs.stability-check}
+
+      Give:
+      1. Overall readiness score (1-10)
+      2. Blocking issues that must be fixed before release
+      3. Recommended issues to fix soon
+      4. Clear Go/No-Go recommendation
+      5. Short rationale

package/pipelines/tdd-review.pipeline.yaml

@@ -0,0 +1,78 @@
+name: tdd-review
+description: "Full TDD cycle with test quality and code review gates — ideal for new features or refactoring."
+report:
+  agent: planner
+  focus: "TDD cycle outcomes, test quality, and implementation readiness"
+
+
+stages:
+  - id: analyze
+    agent: planner
+    task: >
+      Analyze the codebase and create a step-by-step implementation plan for: {task}.
+      Include acceptance criteria, test strategy, edge cases, architecture decisions,
+      likely files to change, risks, and unknowns.
+      If the task is ambiguous or important context is missing, say so explicitly.
+
+  - id: write-tests
+    agent: worker
+    task: >
+      Write tests according to this plan: {outputs.analyze}.
+      Cover happy paths, error paths, boundary values, and edge cases.
+      Use the project's existing test framework and conventions.
+      Do not modify production code in this stage.
+      After writing tests, report changed files and the commands needed to run them.
+    gate:
+      type: review-loop
+      maxRounds: 3
+      targetScore: 9
+      reviewers:
+        - focus: "Do the tests cover ALL scenarios, acceptance criteria, and edge cases from the plan? Identify any missing cases."
+        - focus: "Are tests production-ready: isolated, deterministic, maintainable, and following project conventions?"
+        - focus: "Are error paths, boundary values, async/failure behavior, and unusual inputs covered where relevant?"
+
+  - id: implement
+    agent: worker
+    task: >
+      Implement the code to make these tests pass: {outputs.write-tests}.
+      Follow the plan: {outputs.analyze}.
+      Keep changes minimal, focused, and consistent with project conventions.
+      Do not modify tests unless a test is clearly wrong; if you modify a test, explain why.
+
+    gate:
+      type: review-loop
+      maxRounds: 3
+      targetScore: 8
+      reviewers:
+        - focus: "Does the implementation satisfy all acceptance criteria and make the intended tests pass?"
+        - focus: "Is the code simple, readable, well-structured, and consistent with existing project patterns?"
+        - focus: "Does the implementation handle errors and edge cases without overengineering or hidden behavior?"
+
+  - id: verify
+    agent: worker
+    task: >
+      Run ALL tests in the project using the existing package manager or test scripts.
+      Report:
+      1. Which tests pass and fail
+      2. Any regressions introduced
+      3. Coverage if available
+      4. Commands attempted and any blockers
+      Implementation context: {outputs.implement}
+
+  - id: propose-next
+    parallel:
+      - id: next-steps
+        agent: oracle
+        task: >
+          Based on the current project state, test results: {outputs.verify},
+          and this completed task ({task}),
+          what are the 3 most impactful things to work on next?
+          Consider technical debt, user-facing features, and architecture improvements.
+          Return exactly 3 prioritized next steps with rationale.
+
+      - id: risks
+        agent: reviewer
+        task: >
+          Review the project state after this change: {outputs.verify}.
+          What risks, bottlenecks, or areas need attention before continuing?
+          Return a concise risk report with severity.