pi-dev-team 0.2.0

package/templates/agents/angular-testing.md

@@ -0,0 +1,66 @@
+---
+name: angular-testing
+description: Angular component testing — TestBed setup, component harnesses, OnPush testing, RxJS marble testing, no direct DOM queries
+tools: Read, Grep, Glob
+effort: medium
+---
+
+# Angular Testing
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=good Angular testing, warn=anti-patterns, fail=unreliable tests
+Severity: error=test won't catch regressions, warning=anti-pattern, suggestion=improvement
+Confidence: high=mechanical (use harness, fix TestBed); medium=test design; none=domain context
+
+Context needs: full-file
+File scope: `*.spec.ts`
+
+## Activates when
+
+`@angular/core` in `package.json` dependencies.
+
+## Skip
+
+Return skip when no `.spec.ts` files for Angular components/services in the changeset.
+
+## Detect
+
+TestBed setup:
+
+- Over-configured TestBed (importing entire modules instead of declaring only what's needed)
+- Missing `TestBed.compileComponents()` for components with external templates
+- Not resetting TestBed between tests when configuration changes
+
+Component harnesses:
+
+- Direct DOM queries (`querySelector`, `nativeElement`) instead of `HarnessPredicate`
+- Missing Material component harnesses when `@angular/material` is used
+- Not using `TestbedHarnessEnvironment.loader(fixture)` for harness access
+
+OnPush change detection:
+
+- Tests that pass with Default but fail with OnPush (missing `fixture.detectChanges()`)
+- Missing `ChangeDetectorRef.markForCheck()` after programmatic state changes
+- Not wrapping async operations that update state
+
+RxJS testing:
+
+- Testing observables with `subscribe` + `done` callback instead of marble testing
+- Missing `fakeAsync`/`tick` for time-dependent observables
+- Not unsubscribing in `afterEach` (subscription leaks)
+- Using real timers instead of `TestScheduler`
+
+HTTP testing:
+
+- Mocking `HttpClient` directly instead of using `HttpClientTestingModule`
+- Not verifying outstanding requests with `httpTestingController.verify()`
+- Missing error response testing
+
+## Ignore
+
+Non-Angular tests, E2E tests (Protractor/Cypress), service worker tests.

package/templates/agents/csharp-quality.md

@@ -0,0 +1,63 @@
+---
+name: csharp-quality
+description: "C# code quality — nullable reference types, async/await discipline, record types for DTOs, dependency injection patterns"
+tools: Read, Grep, Glob
+effort: low
+---
+
+# C# Quality
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=modern C#, warn=improvements needed, fail=unsafe patterns
+Severity: error=null safety issue or async misuse, warning=non-modern pattern, suggestion=style
+Confidence: high=mechanical (enable nullable, use record); medium=design choice; none=domain context
+
+Context needs: diff-only
+File scope: `*.cs`
+
+## Activates when
+
+`.csproj` or `.sln` exists.
+
+## Skip
+
+Return skip when no `.cs` files in the changeset.
+
+## Detect
+
+Nullable reference types:
+
+- `<Nullable>enable</Nullable>` missing in `.csproj`
+- Null-forgiving operator (`!`) used without safety check
+- Missing null checks at public API boundaries
+- `dynamic` type usage (loses type safety)
+
+Async/await:
+
+- `async void` methods (except event handlers)
+- `.Result` or `.Wait()` on tasks (deadlock risk)
+- Missing `ConfigureAwait(false)` in library code
+- Fire-and-forget tasks without error handling
+
+Modern C#:
+
+- Classes used for DTOs where `record` types would be immutable and concise
+- Manual `Equals`/`GetHashCode` where `record` handles it
+- `string.Format` instead of string interpolation
+- `switch` statements that could use pattern matching
+
+Dependency injection:
+
+- `new`-ing services instead of injecting via constructor
+- Service locator anti-pattern (`IServiceProvider.GetService` in business logic)
+- Missing interface for testability
+- Transient services holding state
+
+## Ignore
+
+Test projects, generated code, migration files, Razor views.

package/templates/agents/esm-enforcer.md

@@ -0,0 +1,52 @@
+---
+name: esm-enforcer
+description: ES Modules enforcement — import/export only, no require/module.exports, no __dirname/__filename
+tools: Read, Grep, Glob
+effort: low
+---
+
+# ESM Enforcer
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=ESM compliant, warn=minor CJS remnants, fail=CJS patterns in new code
+Severity: error=require() or module.exports in source, warning=__dirname/__filename usage, suggestion=dynamic import opportunity
+Confidence: high=mechanical (replace require with import); medium=judgment call (dynamic require); none=third-party constraint
+
+Context needs: diff-only
+File scope: `*.ts`, `*.tsx`, `*.js`, `*.jsx`, `*.mjs`
+
+## Activates when
+
+Any JS/TS project detected. Always-on for JavaScript and TypeScript projects.
+
+## Skip
+
+Return skip when no JS/TS files in the changeset, or when files are in `node_modules/`.
+
+## Detect
+
+CJS patterns in source code:
+
+- `require()` calls (except in `.cjs` config files like `jest.config.cjs`)
+- `module.exports` or `exports.` assignments
+- `__dirname` or `__filename` (use `import.meta.dirname` / `import.meta.filename` or `fileURLToPath(import.meta.url)`)
+
+Package.json:
+
+- Missing `"type": "module"` (warn on first detection, do not repeat)
+
+File extensions:
+
+- `.js` files that should be `.mjs` in a non-ESM package (or add `"type": "module"`)
+
+## Ignore
+
+- `.cjs` files (legitimate CJS config files)
+- Files in `node_modules/`
+- Generated files
+- Test configuration files that require CJS for tooling compatibility

package/templates/agents/front-end-testing.md

@@ -0,0 +1,65 @@
+---
+name: front-end-testing
+description: Behavior-driven UI testing — query priority, browser-mode preference, HTTP interceptors, framework-agnostic
+tools: Read, Grep, Glob
+effort: medium
+---
+
+# Front-End Testing
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=good testing practices, warn=anti-patterns, fail=tests unreliable or untestable
+Severity: error=unreliable test pattern, warning=anti-pattern, suggestion=improvement
+Confidence: high=mechanical (fix query priority); medium=test design; none=requires domain context
+
+Context needs: full-file
+File scope: `*.test.ts`, `*.test.tsx`, `*.spec.ts`, `*.spec.tsx`, `*.test.js`, `*.test.jsx`
+
+## Activates when
+
+Any frontend framework detected (React, Vue, Svelte, Angular).
+
+## Skip
+
+Return skip when no frontend test files in the changeset.
+
+## Detect
+
+Query priority (most to least preferred):
+
+1. `getByRole` — accessible queries first
+2. `getByLabelText` — form fields
+3. `getByPlaceholderText` — fallback for unlabeled inputs
+4. `getByText` — visible text content
+5. `getByDisplayValue` — current form values
+6. `getByAltText` — images
+7. `getByTitle` — title attributes
+8. `getByTestId` — last resort only
+
+Flag violations of this priority order.
+
+Browser-mode preference:
+
+- Prefer Vitest browser mode or Playwright component testing over jsdom
+- Flag tests that depend on jsdom quirks (layout, intersection observer, etc.)
+
+HTTP interceptors:
+
+- Prefer MSW (Mock Service Worker) over manual fetch/XHR mocking
+- Flag direct `jest.mock` of fetch/axios — use interceptors for realistic testing
+- For Angular: prefer `HttpClientTestingModule` over manual spy injection
+
+Behavior-driven:
+
+- Tests should describe user behavior, not component internals
+- Test names should read as scenarios ("when user clicks submit, form data is sent")
+- Avoid testing CSS classes, internal state, or lifecycle methods directly
+
+## Ignore
+
+Backend tests, E2E/integration tests, non-UI unit tests.

package/templates/agents/go-quality.md

@@ -0,0 +1,65 @@
+---
+name: go-quality
+description: Go code quality — error handling discipline, interface segregation, no naked returns, struct embedding patterns
+tools: Read, Grep, Glob
+effort: low
+---
+
+# Go Quality
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=idiomatic Go, warn=improvements needed, fail=error handling gaps
+Severity: error=ignored error or unsafe pattern, warning=non-idiomatic, suggestion=style
+Confidence: high=mechanical (handle error, remove naked return); medium=design choice; none=domain context
+
+Context needs: diff-only
+File scope: `*.go`
+
+## Activates when
+
+`go.mod` exists.
+
+## Skip
+
+Return skip when no `.go` files in the changeset.
+
+## Detect
+
+Error handling:
+
+- Ignored errors (`_ = someFunc()` without justification)
+- Error not checked after function call that returns error
+- Error wrapping without context (`return err` instead of `return fmt.Errorf("doing X: %w", err)`)
+- Panics in library code (only acceptable in `main` or test helpers)
+
+Returns:
+
+- Naked returns in functions longer than a few lines
+- Named return values that aren't needed for documentation or defer
+
+Interfaces:
+
+- Large interfaces (>5 methods) — prefer small, composable interfaces
+- Interfaces defined by the implementer instead of the consumer
+- Unused interface methods
+
+Struct patterns:
+
+- Embedding for code reuse rather than composition (prefer composition)
+- Exported fields on structs that should be private
+- Missing constructors for structs with required fields
+
+Concurrency:
+
+- Goroutine leaks (goroutine started without cancellation or done channel)
+- Shared state without mutex or channel protection
+- `sync.WaitGroup` misuse (Add after Go)
+
+## Ignore
+
+Test files (test helpers may legitimately panic), generated code, vendor directory.

package/templates/agents/python-quality.md

@@ -0,0 +1,62 @@
+---
+name: python-quality
+description: Python code quality — type hints, exception handling, modern idioms, dataclass/Pydantic patterns
+tools: Read, Grep, Glob
+effort: low
+---
+
+# Python Quality
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=clean Python, warn=improvements needed, fail=unsafe patterns
+Severity: error=bare except or type safety issue, warning=missing types or anti-pattern, suggestion=modern idiom
+Confidence: high=mechanical (add type hint, use f-string); medium=design choice; none=domain context needed
+
+Context needs: diff-only
+File scope: `*.py`
+
+## Activates when
+
+`pyproject.toml`, `requirements.txt`, or `setup.py` exists.
+
+## Skip
+
+Return skip when no `.py` files in the changeset.
+
+## Detect
+
+Type hints:
+
+- Missing type annotations on function signatures (public APIs must have types)
+- `Any` used without justification
+- No `mypy` or `pyright` config for strict checking
+- `# type: ignore` without explanation
+
+Exception handling:
+
+- Bare `except:` or `except Exception:` without re-raise or specific handling
+- Silencing exceptions with `pass`
+- Catching too broad (Exception when only ValueError is expected)
+- Missing `from` in `raise ... from` chains
+
+Modern idioms:
+
+- `format()` or `%` string formatting instead of f-strings
+- Manual dict/list construction instead of comprehensions
+- `type()` checks instead of `isinstance()`
+- Mutable default arguments (`def f(x=[])`)
+
+Data modeling:
+
+- Plain dicts where `dataclass` or `Pydantic.BaseModel` would add type safety
+- Duplicate field definitions across multiple dicts
+- Missing validation at API boundaries (use Pydantic for request/response)
+
+## Ignore
+
+Django/Flask-specific patterns, test fixtures, script-only files, architecture.

package/templates/agents/react-testing.md

@@ -0,0 +1,61 @@
+---
+name: react-testing
+description: React component testing with Testing Library — anti-patterns, hook testing, behavior-first assertions
+tools: Read, Grep, Glob
+effort: medium
+---
+
+# React Testing
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=good test practices, warn=anti-patterns detected, fail=tests give false confidence
+Severity: error=test doesn't verify behavior, warning=anti-pattern, suggestion=improvement opportunity
+Confidence: high=mechanical (remove unnecessary act(), use getByRole); medium=test design judgment; none=requires domain context
+
+Context needs: full-file
+File scope: `*.test.ts`, `*.test.tsx`, `*.spec.ts`, `*.spec.tsx`
+
+## Activates when
+
+`react` or `react-dom` in `package.json` dependencies.
+
+## Skip
+
+Return skip when no test files for React components in the changeset.
+
+## Detect
+
+Testing Library best practices:
+
+- Using `getByTestId` when `getByRole`, `getByLabelText`, or `getByText` would work
+- Wrapping non-async operations in `act()` unnecessarily
+- Using `container.querySelector` instead of Testing Library queries
+- Missing `waitFor` for async state updates
+
+Anti-patterns:
+
+- Testing implementation details (internal state, method calls)
+- Shallow rendering (`enzyme.shallow`) — test behavior, not component tree
+- Snapshot tests as the only assertion (fragile, low signal)
+- Mocking too many internals — test the component as a user would use it
+
+Hook testing:
+
+- Testing hooks through implementation rather than through a component
+- Missing `renderHook` for custom hooks that don't render UI
+- Not wrapping state updates in `act()` when testing hooks directly
+
+Assertions:
+
+- Missing assertions (test runs but doesn't verify anything)
+- Asserting on implementation artifacts instead of user-visible behavior
+- `toMatchSnapshot` without more specific assertions alongside it
+
+## Ignore
+
+Unit tests for non-React code, E2E tests, API tests (handled by other agents).

package/templates/agents/ts-enforcer.md

@@ -0,0 +1,60 @@
+---
+name: ts-enforcer
+description: TypeScript strict mode enforcement — no any types, schema-first at trust boundaries, type vs interface discipline, strict tsconfig audit
+tools: Read, Grep, Glob
+effort: low
+---
+
+# TypeScript Enforcer
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=strict TypeScript, warn=improvements needed, fail=type safety violations
+Severity: error=`any` type or missing validation at boundary, warning=loose type, suggestion=style
+Confidence: high=mechanical (replace any, add type annotation); medium=judgment call (type vs interface); none=requires domain context
+
+Context needs: diff-only
+File scope: `*.ts`, `*.tsx`
+
+## Activates when
+
+`tsconfig.json` exists or `typescript` is in `package.json` dependencies/devDependencies.
+
+## Skip
+
+Return skip when no `.ts`/`.tsx` files in the changeset.
+
+## Detect
+
+Type safety:
+
+- Explicit `any` type annotations (except in test mocks with justification)
+- Implicit `any` from missing return types on exported functions
+- Type assertions (`as`) that widen types without explanation
+- Non-null assertions (`!`) without safety check
+
+Trust boundaries:
+
+- External API responses consumed without runtime validation (use Zod, io-ts, or similar)
+- User input accepted without schema validation
+- Environment variables used without type narrowing
+
+Type discipline:
+
+- `interface` used for object shapes that should be `type` (union types, mapped types)
+- `type` used where `interface` would enable declaration merging (public APIs)
+- Enum used where union type suffices
+
+Strict config:
+
+- `tsconfig.json` missing `strict: true`
+- `skipLibCheck: true` hiding type errors
+- `any` allowed via `noImplicitAny: false`
+
+## Ignore
+
+Runtime logic, test quality, naming, architecture (handled by other agents).

package/templates/agents/twelve-factor-audit.md

@@ -0,0 +1,49 @@
+---
+name: twelve-factor-audit
+description: Twelve-factor app methodology audit — checks all 12 factors with language-appropriate examples
+tools: Read, Grep, Glob
+effort: medium
+---
+
+# Twelve-Factor Audit
+
+Output JSON:
+
+```json
+{"status": "pass|warn|fail|skip", "issues": [{"severity": "error|warning|suggestion", "confidence": "high|medium|none", "file": "", "line": 0, "message": "", "suggestedFix": ""}], "summary": ""}
+```
+
+Status: pass=12-factor compliant, warn=violations detected, fail=critical anti-patterns
+Severity: error=security or reliability risk, warning=operational concern, suggestion=best practice
+Confidence: high=mechanical (hardcoded config, missing health check); medium=design judgment; none=infrastructure context needed
+
+Context needs: project-structure
+
+## Activates when
+
+Service/API project detected: has Dockerfile, server entry point, or cloud config (Kubernetes manifests, cloud formation, etc.).
+
+## Skip
+
+Return skip when project is a library, CLI tool, or static site without a server component.
+
+## Detect
+
+| Factor | What to check |
+|--------|--------------|
+| **I. Codebase** | Single repo per service? Multiple deploys from one codebase? |
+| **II. Dependencies** | All deps declared (lockfile committed)? No system-level assumptions? |
+| **III. Config** | Config in env vars? No hardcoded URLs, credentials, or feature flags in code? |
+| **IV. Backing services** | Database, cache, queue treated as attached resources? Connection strings via env? |
+| **V. Build, release, run** | Strict separation? Build produces artifact, release combines with config, run executes? |
+| **VI. Processes** | Stateless processes? No sticky sessions? No local filesystem for shared state? |
+| **VII. Port binding** | Self-contained via port binding? Not relying on runtime injection into a webserver? |
+| **VIII. Concurrency** | Scale out via process model? No in-memory state that prevents horizontal scaling? |
+| **IX. Disposability** | Fast startup? Graceful shutdown? SIGTERM handling? |
+| **X. Dev/prod parity** | Same backing services in dev/prod? No "works on my machine" patterns? |
+| **XI. Logs** | Treat logs as event streams? Write to stdout, not files? No log file rotation in app? |
+| **XII. Admin processes** | One-off tasks as scripts? Database migrations as code? Not manual SQL? |
+
+## Ignore
+
+Application logic, code quality, test coverage (handled by other agents).