@garethdaine/agentops 0.9.0

package/templates/delivery/handover/support-escalation-matrix.md

@@ -0,0 +1,56 @@
+# Delivery Template: Support Escalation Matrix
+
+```markdown
+# Support Escalation Matrix — [Project Name]
+
+**Effective from:** [date]
+**Review date:** [date + 3 months]
+
+## Severity Definitions
+
+| Level | Definition | Example | Response Target | Resolution Target |
+|-------|-----------|---------|----------------|-------------------|
+| P1 — Critical | System down, data loss, security breach | Production API returning 500 for all users | 15 minutes | 4 hours |
+| P2 — High | Major feature broken, significant user impact | Authentication failing for subset of users | 1 hour | 8 hours |
+| P3 — Medium | Feature degraded, workaround available | Report generation slow but functional | 4 hours | 2 business days |
+| P4 — Low | Minor issue, cosmetic, enhancement request | UI alignment issue on one browser | 1 business day | Next sprint |
+
+## Escalation Path
+
+### Level 1: Client Internal Team
+**Handles:** Known issues, configuration changes, password resets, FAQ questions
+**Contact:** [client support email/channel]
+**Hours:** Business hours
+
+### Level 2: Development Team
+**Handles:** Bug investigation, code fixes, performance issues
+**Contact:** [dev team email/Slack channel]
+**Hours:** Business hours (P1/P2: on-call after hours)
+
+### Level 3: Architecture / Infrastructure
+**Handles:** System design issues, infrastructure failures, security incidents
+**Contact:** [tech lead / architect contact]
+**Hours:** On-call for P1 only
+
+### Emergency
+**Handles:** Security breaches, data loss, complete system failure
+**Contact:** [emergency phone number]
+**Process:** Call immediately, do not wait for email response
+
+## Escalation Triggers
+
+| Situation | Escalate To |
+|-----------|------------|
+| Issue unresolved past response target | Next level |
+| Issue affects >50% of users | Level 2 minimum |
+| Security incident suspected | Level 3 + emergency |
+| Data loss or corruption | Level 3 + emergency |
+| Client executive escalation | Level 3 |
+
+## Communication Protocol
+
+- P1/P2: Status updates every 30 minutes until resolved
+- P3: Status update within 4 hours, then daily
+- P4: Update in weekly status report
+- All incidents: Post-mortem within 5 business days for P1/P2
+```

package/templates/delivery/implementation/blocker-escalation-template.md

@@ -0,0 +1,55 @@
+# Delivery Template: Blocker Escalation
+
+```markdown
+# Blocker Escalation Report
+
+**Date:** [date]
+**Raised by:** [name]
+**Sprint:** [sprint number]
+**Blocked item:** [task/story reference]
+
+## Blocker Description
+
+[Clear, specific description of what is blocking progress]
+
+## Impact
+
+- **What is blocked:** [specific tasks that cannot proceed]
+- **Who is affected:** [team members waiting]
+- **Delivery impact:** [sprint goal at risk? deadline affected?]
+- **Business impact:** [client-facing consequences if not resolved]
+
+## Timeline
+
+| Event | Date |
+|-------|------|
+| Blocker identified | [date] |
+| First attempt to resolve | [date] |
+| Escalation raised | [date] |
+| Resolution deadline | [date] |
+
+## What Has Been Tried
+
+1. [Attempted resolution and outcome]
+2. [Attempted resolution and outcome]
+3. [Attempted resolution and outcome]
+
+## Help Needed
+
+**Specific ask:** [What exactly do you need to unblock?]
+**From whom:** [Person or team who can help]
+**By when:** [Deadline for resolution]
+
+## Proposed Workarounds
+
+| Option | Trade-offs | Recommendation |
+|--------|-----------|---------------|
+| [workaround] | [trade-offs] | Recommended / Not recommended |
+
+## Decision
+
+**Decision:** [What was decided]
+**Decided by:** [name]
+**Date:** [date]
+**Follow-up actions:** [any remaining work]
+```

package/templates/delivery/implementation/sprint-planning-template.md

@@ -0,0 +1,49 @@
+# Delivery Template: Sprint Planning
+
+```markdown
+# Sprint Planning — Sprint [N]
+
+**Sprint dates:** [start] — [end]
+**Sprint goal:** [one sentence describing the sprint's primary objective]
+**Team capacity:** [available person-days]
+
+## Committed Items
+
+| # | Item | Type | Estimate | Assignee | Dependencies | Risk |
+|---|------|------|----------|----------|-------------|------|
+| 1 | [description] | Feature/Bug/Tech Debt | S/M/L | [name] | [deps] | [risk] |
+| 2 | [description] | Feature/Bug/Tech Debt | S/M/L | [name] | [deps] | [risk] |
+
+## Capacity
+
+| Team Member | Available Days | Committed Days | Buffer |
+|------------|---------------|---------------|--------|
+| [name] | [N] | [N] | [N] |
+
+**Total capacity:** [N] days
+**Total committed:** [N] days
+**Buffer:** [N] days ([%])
+
+*Target: commit to 80% of capacity, reserve 20% for unplanned work*
+
+## Sprint Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| [risk] | H/M/L | H/M/L | [plan] |
+
+## Carry-over from Previous Sprint
+
+| Item | Reason for Carry-over | Adjusted Estimate |
+|------|----------------------|------------------|
+| [item] | [why it wasn't completed] | [new estimate] |
+
+## Definition of Done
+
+- [ ] Code complete and reviewed
+- [ ] Tests passing (unit + integration)
+- [ ] No critical or high code review findings
+- [ ] Documentation updated (if applicable)
+- [ ] Deployed to staging and verified
+- [ ] Product owner acceptance
+```

package/templates/delivery/implementation/task-decomposition-guide.md

@@ -0,0 +1,59 @@
+# Delivery Template: Task Decomposition Guide
+
+## Hierarchy
+
+```
+Epic (business capability)
+  └── Story (user-facing value)
+       └── Task (implementable unit of work)
+            └── Sub-task (atomic step)
+```
+
+## Sizing Guide
+
+| Size | Description | Typical Effort | Example |
+|------|-------------|---------------|---------|
+| XS | Trivial change, no unknowns | <2 hours | Fix typo, update config value |
+| S | Well-understood, single file | 2-4 hours | Add validation to existing endpoint |
+| M | Multiple files, some complexity | 1-2 days | New API endpoint with tests |
+| L | Cross-cutting, moderate unknowns | 3-5 days | New service with adapter integration |
+| XL | Significant scope, high unknowns | 1-2 weeks | New module or subsystem — break this down further |
+
+**Rule: If a task is XL, it must be decomposed further.** No task should take more than 5 days.
+
+## Decomposition Checklist
+
+For each story, identify:
+
+1. **Data model changes** — New tables, columns, migrations, indexes
+2. **Backend logic** — Service functions, business rules, validation
+3. **API layer** — Route handlers, middleware, request/response schemas
+4. **Frontend** — Components, pages, state management, API calls
+5. **Integration** — External API adapters, contracts, mocks
+6. **Tests** — Unit, integration, contract, E2E for each component
+7. **Documentation** — API docs, ADRs, README updates
+8. **Infrastructure** — Environment variables, Docker changes, CI/CD updates
+
+## Dependency Mapping
+
+For each task, document:
+- **Depends on:** [which tasks must complete first]
+- **Blocks:** [which tasks are waiting on this]
+- **Can parallelize with:** [tasks that can run simultaneously]
+
+## Example Decomposition
+
+**Story:** "As a user, I can view my procurement orders filtered by status"
+
+| # | Task | Size | Dependencies |
+|---|------|------|-------------|
+| 1 | Add Order model to Prisma schema + migration | S | — |
+| 2 | Create OrderRepository with tenant-scoped queries | M | 1 |
+| 3 | Create OrderService with filtering logic | M | 2 |
+| 4 | Create GET /api/v1/orders endpoint | M | 3 |
+| 5 | Add input validation schema (zod) | S | 4 |
+| 6 | Write unit tests for OrderService | M | 3 |
+| 7 | Write integration tests for orders endpoint | M | 4 |
+| 8 | Create OrderList frontend component | M | 4 |
+| 9 | Add status filter UI with query params | S | 8 |
+| 10 | Write component tests | S | 8, 9 |

package/templates/delivery/qa/test-plan-template.md

@@ -0,0 +1,76 @@
+# Delivery Template: Test Plan
+
+```markdown
+# Test Plan — [Project/Feature Name]
+
+**Version:** [1.0]
+**Prepared by:** [name]
+**Date:** [date]
+**Status:** Draft / Approved / In Execution / Complete
+
+## 1. Scope
+
+### In Scope
+- [Feature/component to test]
+- [Feature/component to test]
+
+### Out of Scope
+- [What is NOT being tested and why]
+
+## 2. Test Strategy
+
+| Test Type | Scope | Framework | Responsibility |
+|-----------|-------|-----------|---------------|
+| Unit | Business logic, utilities | Vitest/Jest | Developer |
+| Integration | API endpoints, database | Supertest | Developer |
+| Component | UI components | Testing Library | Frontend dev |
+| Contract | External API adapters | Pact/manual | Backend dev |
+| E2E | Critical user flows | Playwright | QA |
+| Performance | API response times | k6/Artillery | DevOps |
+| Security | OWASP Top 10 | /agentops:review | Developer |
+
+## 3. Test Environment
+
+| Environment | URL | Database | Purpose |
+|-------------|-----|----------|---------|
+| Local | localhost:3000 | SQLite/Docker | Development |
+| CI | — | Docker | Automated pipeline |
+| Staging | staging.example.com | Staging DB | Pre-production validation |
+| Production | app.example.com | Production DB | Smoke tests only |
+
+## 4. Entry Criteria
+- [ ] Code complete and merged to feature branch
+- [ ] Unit tests passing in CI
+- [ ] Test environment provisioned and accessible
+- [ ] Test data seeded
+
+## 5. Exit Criteria
+- [ ] All critical and high test cases passing
+- [ ] No unresolved critical or high defects
+- [ ] Test coverage meets target (statements >80%)
+- [ ] Performance benchmarks within acceptable thresholds
+- [ ] Security review completed with no critical findings
+
+## 6. Test Cases
+
+| ID | Category | Description | Priority | Status |
+|----|----------|-------------|----------|--------|
+| TC-001 | Functional | [test description] | Critical | Pass/Fail/Blocked |
+| TC-002 | Security | [test description] | High | Pass/Fail/Blocked |
+
+## 7. Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| Incomplete test data | Medium | High | Seed scripts verified before testing |
+| Environment instability | Low | High | Fallback to local testing |
+
+## 8. Schedule
+
+| Phase | Start | End | Owner |
+|-------|-------|-----|-------|
+| Unit/Integration | [date] | [date] | Dev team |
+| E2E | [date] | [date] | QA |
+| Performance | [date] | [date] | DevOps |
+| UAT | [date] | [date] | Client |
+```

package/templates/delivery/qa/test-results-template.md

@@ -0,0 +1,55 @@
+# Delivery Template: Test Results Report
+
+```markdown
+# Test Results Report — [Project/Feature Name]
+
+**Date:** [date]
+**Tester:** [name]
+**Environment:** [staging/production]
+**Build:** [commit hash or version]
+
+## Executive Summary
+
+[2-3 sentences: overall result, key findings, recommendation to proceed or hold]
+
+## Results Overview
+
+| Metric | Value |
+|--------|-------|
+| Total test cases | [N] |
+| Passed | [N] ([%]) |
+| Failed | [N] ([%]) |
+| Blocked | [N] ([%]) |
+| Skipped | [N] ([%]) |
+
+## Coverage
+
+| Category | Statements | Branches | Functions | Lines |
+|----------|-----------|----------|-----------|-------|
+| Overall | [%] | [%] | [%] | [%] |
+| Critical paths | [%] | [%] | [%] | [%] |
+
+## Failed Test Cases
+
+| ID | Description | Expected | Actual | Severity | Status |
+|----|-------------|----------|--------|----------|--------|
+| TC-NNN | [description] | [expected] | [actual] | Critical/High/Med | Open/Fixed |
+
+## Defects Found
+
+| ID | Title | Severity | Status | Assigned To |
+|----|-------|----------|--------|-------------|
+| DEF-001 | [title] | Critical/High/Med/Low | Open/Fixed/Deferred | [name] |
+
+## Performance Results
+
+| Endpoint | p50 | p95 | p99 | Target | Status |
+|----------|-----|-----|-----|--------|--------|
+| GET /api/orders | [ms] | [ms] | [ms] | <200ms | Pass/Fail |
+
+## Recommendation
+
+- [ ] **GO** — All critical tests pass, no unresolved critical defects
+- [ ] **CONDITIONAL GO** — Minor issues to address post-deployment
+- [ ] **NO GO** — Critical issues must be resolved before deployment
+```

package/templates/delivery/qa/uat-signoff-template.md

@@ -0,0 +1,44 @@
+# Delivery Template: UAT Sign-off
+
+```markdown
+# User Acceptance Testing Sign-off — [Project/Feature Name]
+
+**Date:** [date]
+**Sprint/Release:** [identifier]
+**UAT Lead:** [name]
+
+## Acceptance Criteria
+
+| # | Criteria | Status | Tested By | Date | Notes |
+|---|---------|--------|-----------|------|-------|
+| 1 | [acceptance criterion from requirements] | Pass/Fail/N/A | [name] | [date] | [notes] |
+| 2 | [acceptance criterion] | Pass/Fail/N/A | [name] | [date] | |
+
+## Demo Walkthrough
+
+- [ ] Feature demonstrated to stakeholders
+- [ ] Edge cases discussed and verified
+- [ ] Error handling shown
+- [ ] Performance acceptable to stakeholders
+
+## Outstanding Issues
+
+| Issue | Severity | Decision | Owner |
+|-------|----------|----------|-------|
+| [description] | [severity] | Fix before release / Accept / Defer | [name] |
+
+## Sign-off
+
+| Role | Name | Decision | Signature | Date |
+|------|------|----------|-----------|------|
+| Product Owner | [name] | Approve / Reject | _________ | [date] |
+| QA Lead | [name] | Approve / Reject | _________ | [date] |
+| Tech Lead | [name] | Approve / Reject | _________ | [date] |
+
+## Conditions of Acceptance
+
+By signing above, stakeholders confirm:
+1. All acceptance criteria have been tested and verified
+2. Outstanding issues have been reviewed and dispositioned
+3. The feature is approved for production deployment
+```

package/templates/governance/codeowners.md

@@ -0,0 +1,60 @@
+# Governance Template: Code Ownership
+
+## CODEOWNERS Template
+
+Generate a CODEOWNERS file by analysing the project structure:
+
+```
+# Code Ownership — Auto-generated by AgentOps
+# Format: path @owner
+
+# Global — default reviewers for everything
+* @team-lead
+
+# Frontend
+src/components/ @frontend-team
+src/pages/ @frontend-team
+src/styles/ @frontend-team
+
+# Backend / API
+src/services/ @backend-team
+src/routes/ @backend-team
+src/middleware/ @backend-team
+
+# Data Layer
+src/models/ @backend-team
+src/repositories/ @backend-team
+prisma/ @backend-team
+
+# Infrastructure
+Dockerfile @devops-team
+docker-compose.yml @devops-team
+.github/workflows/ @devops-team
+terraform/ @devops-team
+
+# Security-sensitive
+src/auth/ @security-lead @team-lead
+src/middleware/auth* @security-lead
+
+# Configuration
+package.json @team-lead
+tsconfig.json @team-lead
+```
+
+## Review Assignment Rules
+
+- PRs require at least 1 approval from a code owner
+- Security-sensitive files require 2 approvals
+- Infrastructure changes require DevOps team review
+- Schema changes require backend lead review
+
+## Domain Expertise Map
+
+| Domain | Expert | Backup |
+|--------|--------|--------|
+| Authentication | [name] | [name] |
+| API Design | [name] | [name] |
+| Database | [name] | [name] |
+| Frontend | [name] | [name] |
+| Infrastructure | [name] | [name] |
+| Security | [name] | [name] |

package/templates/integration/adapter-pattern.md

@@ -0,0 +1,160 @@
+# Mock Integration Framework: Adapter Pattern
+
+## Overview
+
+This template provides a complete adapter pattern for integrating with external enterprise systems. It includes an interface, mock implementation, real implementation, factory, and contract tests.
+
+## File Structure
+
+```
+src/adapters/
+  procurement/
+    types.ts                 # Domain types (NOT external API types)
+    procurement-adapter.ts   # Interface definition
+    mock-adapter.ts          # Mock implementation (dev/test)
+    http-adapter.ts          # Real HTTP implementation
+    adapter-factory.ts       # Factory that selects implementation
+    __tests__/
+      contract.test.ts       # Contract tests (verify mock == real behaviour)
+```
+
+## Step 1: Domain Types (`types.ts`)
+
+Define your domain types independently of external API schemas:
+
+```typescript
+export interface Order {
+  id: string;
+  tenantId: string;
+  orderNumber: string;
+  status: OrderStatus;
+  items: OrderItem[];
+  totalAmount: number;
+  currency: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type OrderStatus = 'draft' | 'submitted' | 'approved' | 'rejected' | 'fulfilled' | 'cancelled';
+
+export interface OrderItem {
+  id: string;
+  sku: string;
+  description: string;
+  quantity: number;
+  unitPrice: number;
+}
+
+export interface CreateOrderInput {
+  items: Omit<OrderItem, 'id'>[];
+  currency?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface PaginatedResult<T> {
+  data: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+```
+
+## Step 2: Interface (`procurement-adapter.ts`)
+
+```typescript
+import type { Order, OrderStatus, CreateOrderInput, PaginatedResult } from './types';
+
+export interface ProcurementAdapter {
+  getOrders(tenantId: string, options?: { status?: OrderStatus; limit?: number; offset?: number }): Promise<PaginatedResult<Order>>;
+  getOrderById(tenantId: string, orderId: string): Promise<Order | null>;
+  createOrder(tenantId: string, input: CreateOrderInput): Promise<Order>;
+  updateOrderStatus(tenantId: string, orderId: string, status: OrderStatus): Promise<Order>;
+  deleteOrder(tenantId: string, orderId: string): Promise<void>;
+}
+```
+
+## Step 3: Mock Implementation (`mock-adapter.ts`)
+
+```typescript
+import { randomUUID } from 'node:crypto';
+import type { ProcurementAdapter } from './procurement-adapter';
+import type { Order, OrderStatus, CreateOrderInput, PaginatedResult } from './types';
+
+export class MockProcurementAdapter implements ProcurementAdapter {
+  private store = new Map<string, Order>();
+
+  constructor() {
+    this.seed();
+  }
+
+  private seed(): void {
+    // Pre-populate with realistic demo data
+    const demoOrders: Order[] = [
+      {
+        id: randomUUID(), tenantId: 'acme-corp', orderNumber: 'PO-2026-001',
+        status: 'approved', currency: 'USD', totalAmount: 45_000,
+        items: [{ id: randomUUID(), sku: 'SRV-ENT-100', description: 'Enterprise Server License', quantity: 10, unitPrice: 4_500 }],
+        createdAt: new Date('2026-03-01'), updatedAt: new Date('2026-03-10'),
+      },
+      // ... more seed data
+    ];
+    demoOrders.forEach((o) => this.store.set(o.id, o));
+  }
+
+  async getOrders(tenantId: string, options?: { status?: OrderStatus; limit?: number; offset?: number }): Promise<PaginatedResult<Order>> {
+    let orders = [...this.store.values()].filter((o) => o.tenantId === tenantId);
+    if (options?.status) orders = orders.filter((o) => o.status === options.status);
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? 20;
+    return { data: orders.slice(offset, offset + limit), total: orders.length, limit, offset };
+  }
+
+  async getOrderById(tenantId: string, orderId: string): Promise<Order | null> {
+    const order = this.store.get(orderId);
+    if (!order || order.tenantId !== tenantId) return null;
+    return order;
+  }
+
+  async createOrder(tenantId: string, input: CreateOrderInput): Promise<Order> {
+    const order: Order = {
+      id: randomUUID(), tenantId, orderNumber: `PO-${Date.now()}`,
+      status: 'draft', currency: input.currency ?? 'USD',
+      totalAmount: input.items.reduce((sum, i) => sum + i.quantity * i.unitPrice, 0),
+      items: input.items.map((i) => ({ ...i, id: randomUUID() })),
+      createdAt: new Date(), updatedAt: new Date(),
+    };
+    this.store.set(order.id, order);
+    return order;
+  }
+
+  async updateOrderStatus(tenantId: string, orderId: string, status: OrderStatus): Promise<Order> {
+    const order = await this.getOrderById(tenantId, orderId);
+    if (!order) throw new Error(`Order ${orderId} not found`);
+    order.status = status;
+    order.updatedAt = new Date();
+    return order;
+  }
+
+  async deleteOrder(tenantId: string, orderId: string): Promise<void> {
+    const order = this.store.get(orderId);
+    if (order?.tenantId === tenantId) this.store.delete(orderId);
+  }
+}
+```
+
+## Step 4: Factory (`adapter-factory.ts`)
+
+```typescript
+import type { ProcurementAdapter } from './procurement-adapter';
+import { MockProcurementAdapter } from './mock-adapter';
+// import { HttpProcurementAdapter } from './http-adapter';
+
+export function createProcurementAdapter(): ProcurementAdapter {
+  const useMock = process.env.USE_MOCK_ADAPTERS === 'true' || process.env.NODE_ENV === 'test';
+  if (useMock) {
+    return new MockProcurementAdapter();
+  }
+  // return new HttpProcurementAdapter(env.PROCUREMENT_API_URL, env.PROCUREMENT_API_KEY);
+  throw new Error('Real procurement adapter not configured. Set USE_MOCK_ADAPTERS=true for development.');
+}
+```