@fermindi/pwn-cli 0.1.0

package/templates/workspace/.ai/memory/deadends.md

@@ -0,0 +1,79 @@
+# Failed Approaches & Dead Ends
+
+This file documents approaches that failed, to avoid repeating mistakes.
+
+## Format
+
+Each dead end follows this structure:
+
+```markdown
+## DE-XXX: Failed Approach Title
+**Date:** YYYY-MM-DD
+**Attempted:** What we tried
+**Problem:** Why it failed
+**Solution:** What worked instead
+**Time Spent:** Approximate hours
+**Reference:** Related decision or issue
+```
+
+---
+
+## Adding New Dead Ends
+
+When an approach fails:
+
+1. Assign next DE number (DE-001, DE-002, etc.)
+2. Fill in all sections while fresh in memory
+3. Commit with message: `docs: add DE-XXX dead end`
+4. Reference in code: `// See DE-XXX - why we don't use X`
+
+---
+
+## Categories
+
+- **Architecture:** Structural decisions that didn't work
+- **Performance:** Optimization attempts that backfired
+- **Dependencies:** Library choices that caused problems
+- **Testing:** Test strategies that were too brittle
+- **Integration:** External service integrations that failed
+- **Data Modeling:** Schema or object structure issues
+- **DevOps:** Deployment/infrastructure approaches
+
+---
+
+## Template for New Dead End
+
+```markdown
+## DE-XXX: [Title]
+**Date:** YYYY-MM-DD
+**Attempted:** (What we tried and why we thought it would work)
+**Problem:** (Why it failed - specific errors, limitations, etc.)
+**Solution:** (What we did instead - working approach)
+**Time Spent:** X hours
+**Reference:** (Link to related DEC, issue, or PR)
+```
+
+---
+
+## Tips for Recording Dead Ends
+
+- Be honest about what failed
+- Include error messages and specific blockers
+- Document the solution for future reference
+- Note if this is a category-wide dead end or specific case
+- Update if you discover new info about why it failed
+
+---
+
+## Archiving
+
+Dead ends are archived to `/context/dead-ends/archive/` after:
+- 90 days with no new references
+- Superseded by later approaches
+- External changes (library update) invalidate the issue
+
+---
+
+## Current Backlog
+
+Document new dead ends as they occur. Keep the most recent 5-10 active.

package/templates/workspace/.ai/memory/decisions.md

@@ -0,0 +1,58 @@
+# Architectural Decisions
+
+This file tracks major architectural decisions made for this project.
+
+## Format
+
+Each decision follows this structure:
+
+```markdown
+## DEC-XXX: Decision Title
+**Date:** YYYY-MM-DD
+**Status:** Active | Superseded | Deprecated
+**Context:** Why this decision was needed
+**Decision:** What was decided
+**Rationale:** Why this is the best choice
+**Impact:** What this affects
+**Alternatives Considered:** Other options we evaluated
+```
+
+---
+
+## DEC-001: Example Decision
+**Date:** 2026-01-21
+**Status:** Active
+**Context:** (Describe the situation that required this decision)
+**Decision:** (State what was decided)
+**Rationale:** (Explain why this is the right choice)
+**Impact:** (List what this affects - files, patterns, dependencies)
+**Alternatives Considered:**
+- Option A: (why rejected)
+- Option B: (why rejected)
+
+---
+
+## Adding New Decisions
+
+When making significant architectural choices:
+1. Assign next DEC number (DEC-002, DEC-003, etc.)
+2. Fill in all sections
+3. Commit with message: `docs: add DEC-XXX decision`
+4. Reference in code comments: `// See DEC-XXX`
+
+## Decision Categories
+
+- **Technology Choices:** Frameworks, libraries, tools
+- **Architecture Patterns:** How systems interact
+- **Data Models:** Database schemas, API contracts
+- **Security:** Authentication, authorization, encryption
+- **Performance:** Caching, optimization strategies
+- **DevOps:** Deployment, CI/CD, monitoring
+
+## Superseding Decisions
+
+When a decision changes:
+1. Update status to "Superseded"
+2. Link to new decision: "Superseded by DEC-XXX"
+3. Don't delete - keep for historical context
+4. Move to `.ai/memory/archive/` after 90 days unused

package/templates/workspace/.ai/memory/patterns.md

@@ -0,0 +1,65 @@
+# Codebase Patterns
+
+This file documents recurring patterns discovered during development.
+
+## Format
+
+Each pattern follows this structure:
+
+```markdown
+## Pattern Category
+
+### Pattern Name
+**Context:** When this pattern applies
+**Pattern:** Code example or description
+**Rationale:** Why this is the better approach
+**Example Location:** Where to find real examples
+```
+
+---
+
+## Add New Patterns
+
+When you discover a useful pattern:
+
+1. Identify the category (Frontend, Backend, Testing, etc.)
+2. Fill in all sections
+3. Add code example if possible
+4. Commit with message: `docs: add pattern - [name]`
+5. Update `patterns/index.md` if this should be auto-applied
+
+---
+
+## Pattern Categories
+
+- **Frontend:** React, TypeScript, styling, component patterns
+- **Backend:** API design, database queries, middleware
+- **Testing:** Unit tests, integration tests, fixtures
+- **Performance:** Caching, memoization, optimization
+- **Security:** Input validation, authentication, authorization
+- **Error Handling:** Exception patterns, recovery strategies
+- **Data Structures:** Modeling domain objects effectively
+
+---
+
+## Template for New Pattern
+
+```markdown
+## [Category]
+
+### [Pattern Name]
+**Context:** (When to use this pattern)
+**Pattern:** (Description or code example)
+**Rationale:** (Why this is better)
+**Example Location:** (Where in codebase)
+```
+
+---
+
+## Notes
+
+- Patterns should be language-agnostic when possible
+- Prioritize patterns that prevent common bugs
+- Link related patterns together
+- Update this file as team learns new approaches
+- Archive rarely-used patterns after 3 months of no references

package/templates/workspace/.ai/patterns/backend/README.md

@@ -0,0 +1,126 @@
+# Backend Patterns
+
+This directory contains design patterns and best practices for backend development.
+
+## Overview
+
+Backend patterns cover:
+- Express.js route structure
+- REST API design
+- Database queries and migrations
+- Error handling and logging
+- Authentication and authorization
+- Data validation
+- Performance optimization
+- Middleware patterns
+- Integration patterns
+
+## Structure
+
+```
+backend/
+├── README.md                  # This file
+├── express/                   # Express.js patterns
+│   └── README.md             # Express routing and middleware
+├── database/                  # Database patterns
+│   └── README.md             # Query and ORM patterns
+├── api-design/                # REST API patterns
+│   └── README.md             # API structure and conventions
+├── security/                  # Security patterns
+│   └── README.md             # Auth, validation, sanitization
+└── integration/               # Integration patterns
+    └── README.md             # Working with external services
+```
+
+## Auto-Apply Triggers
+
+These patterns are automatically loaded when:
+
+- **File:** `*.routes.ts`, `routes/*.ts` (Express routes)
+- **Import:** `from.*express`, `import.*Router`
+- **Path:** `src/routes/`, `src/api/`
+- **Keyword:** `app.get`, `app.post`, `router.use`
+
+See `patterns/index.md` for trigger configuration.
+
+## Common Patterns
+
+### Route Structure
+```typescript
+// Group related routes together
+// Use middleware for common operations (auth, logging)
+// Keep route handlers thin, logic in services
+// Consistent error handling
+```
+
+### Express Middleware
+- Authentication middleware early in chain
+- Error handling middleware last
+- Logging middleware for all requests
+- Request validation middleware
+- CORS middleware appropriately configured
+
+### API Design
+- RESTful conventions (GET, POST, PUT, DELETE)
+- Consistent response format
+- Proper HTTP status codes
+- Pagination for list endpoints
+- Filtering and sorting support
+
+### Database Queries
+- Use ORM/query builder (not raw SQL)
+- Eager load relationships when needed
+- Avoid N+1 query problems
+- Index frequently-queried columns
+- Use transactions for multi-step operations
+
+### Error Handling
+- Custom error classes for different error types
+- Consistent error response format
+- Log errors with full context
+- Don't expose internal errors to clients
+- Use HTTP status codes correctly
+
+### Validation
+- Validate all user input
+- Use schema validation (Zod, Joi, etc.)
+- Sanitize input to prevent injection
+- Custom validation rules for domain logic
+- Clear error messages for users
+
+### Authentication
+- Use industry-standard auth (JWT, OAuth, etc.)
+- Secure token storage
+- Token expiration and refresh strategy
+- Role-based access control (RBAC)
+- Audit logging of auth events
+
+## Usage
+
+1. Read the relevant sub-directory README for your task
+2. Check code examples for reference implementations
+3. Follow patterns in new routes and services
+4. Update patterns if you discover improvements
+
+## Contributing
+
+Found a better pattern?
+
+1. Document it with examples
+2. Add to appropriate subdirectory
+3. Update this README
+4. Commit with message: `docs: add [pattern name] pattern`
+5. Update triggers in `patterns/index.md` if widely applicable
+
+## Links
+
+- [Express Patterns](express/README.md)
+- [Database Patterns](database/README.md)
+- [API Design](api-design/README.md)
+- [Security Patterns](security/README.md)
+- [Integration Patterns](integration/README.md)
+
+## Version
+
+**Last Updated:** (Set on template injection)
+**Maintained By:** Development Team

package/templates/workspace/.ai/patterns/frontend/README.md

@@ -0,0 +1,103 @@
+# Frontend Patterns
+
+This directory contains design patterns and best practices for frontend development.
+
+## Overview
+
+Frontend patterns cover:
+- React component architecture
+- TypeScript type definitions
+- Styling and CSS strategies
+- State management
+- Performance optimization
+- Accessibility (a11y)
+- Component composition
+- Hook patterns
+
+## Structure
+
+```
+frontend/
+├── README.md                  # This file
+├── react/                     # React-specific patterns
+│   └── README.md             # React component patterns
+├── styling/                   # CSS and styling patterns
+│   └── README.md             # Styling strategies
+├── component-libs/            # UI component library patterns
+│   └── README.md             # Working with component libraries
+└── accessibility/             # A11y patterns
+    └── README.md             # Accessibility patterns
+```
+
+## Auto-Apply Triggers
+
+These patterns are automatically loaded when:
+
+- **File:** `*.tsx`, `*.jsx` (React components)
+- **Import:** `import.*React`, `from.*react`
+- **Path:** `src/components/`
+- **Keyword:** `function Component`, `export default`
+
+See `patterns/index.md` for trigger configuration.
+
+## Common Patterns
+
+### Component Architecture
+- Functional components with hooks (not class components)
+- One component per file
+- Props interfaces at top of file
+- Hooks (useState, useEffect, useContext)
+- Custom hooks for reusable logic
+
+### TypeScript
+- Define interfaces for component props
+- Use `React.FC<Props>` for component type
+- Strict null checks enabled
+- Export types alongside components
+
+### State Management
+- Local state with `useState` for component-only state
+- Context API for shared state
+- Consider Redux/Zustand for complex state
+- Avoid prop drilling (use Context instead)
+
+### Performance
+- Memoize expensive components with `React.memo`
+- Use `useCallback` for stable function references
+- Use `useMemo` for expensive computations
+- Lazy load routes with `React.lazy`
+
+### Styling
+- TailwindCSS for utility-first styling
+- CSS modules for scoped styles
+- Avoid inline styles except for dynamic values
+- Use design tokens for consistency
+
+## Usage
+
+1. Read the relevant sub-directory README for your task
+2. Check code examples for reference implementations
+3. Follow patterns in new components
+4. Update patterns if you discover improvements
+
+## Contributing
+
+Found a better pattern?
+
+1. Document it with examples
+2. Add to appropriate subdirectory
+3. Update this README
+4. Commit with message: `docs: add [pattern name] pattern`
+5. Update triggers in `patterns/index.md` if widely applicable
+
+## Links
+
+- [React Component Patterns](react/README.md)
+- [Styling Strategies](styling/README.md)
+- [Component Libraries](component-libs/README.md)
+- [Accessibility Patterns](accessibility/README.md)
+
+## Version
+
+**Last Updated:** (Set on template injection)
+**Maintained By:** Development Team

package/templates/workspace/.ai/patterns/index.md

@@ -0,0 +1,256 @@
+# Pattern Auto-Apply Trigger Map
+
+This file defines triggers that automatically load relevant patterns during AI sessions.
+
+## How It Works
+
+1. AI agent starts session
+2. Reads this file to register triggers
+3. Monitors file changes, imports, and commands
+4. When trigger matches, loads relevant patterns from `patterns/` subdirectories
+5. Applies patterns to current work
+
+---
+
+## Trigger Types
+
+- **`fileExt`** - File extension patterns (e.g., `*.tsx`, `*.py`)
+- **`import`** - Import statements (e.g., `from react import`)
+- **`command`** - CLI commands (e.g., `pnpm dev`, `npm test`)
+- **`path`** - Directory path patterns (e.g., `src/components/`)
+- **`keyword`** - Code keywords (e.g., `interface`, `class`)
+
+---
+
+## Trigger Format
+
+```yaml
+triggers:
+  - name: "Pattern Name"
+    type: "fileExt | import | command | path | keyword"
+    value: "*.tsx"
+    patterns:
+      - "frontend/react"
+      - "universal/typescript"
+    description: "Loads when working with React components"
+```
+
+---
+
+## Trigger Registry
+
+### Frontend Triggers
+
+```yaml
+triggers:
+  - name: "React Components"
+    type: "fileExt"
+    value: "*.tsx"
+    patterns:
+      - "frontend/react"
+      - "universal/typescript"
+    description: "Auto-loads React component patterns"
+
+  - name: "React Hooks"
+    type: "import"
+    value: "import.*useEffect|useState|useContext"
+    patterns:
+      - "frontend/react/hooks"
+    description: "Loads when using React hooks"
+
+  - name: "Styling"
+    type: "fileExt"
+    value: "*.css,*.scss,*.tailwind"
+    patterns:
+      - "frontend/styling"
+    description: "CSS/styling patterns"
+
+  - name: "Component Library"
+    type: "import"
+    value: "from.*@shadcn|from.*@mui"
+    patterns:
+      - "frontend/component-libs"
+    description: "Component library patterns"
+```
+
+### Backend Triggers
+
+```yaml
+triggers:
+  - name: "Express Routes"
+    type: "fileExt"
+    value: "*.routes.ts,routes/*.ts"
+    patterns:
+      - "backend/express"
+      - "universal/rest-api"
+    description: "Express route patterns"
+
+  - name: "Database Queries"
+    type: "import"
+    value: "from.*prisma|from.*knex|from.*typeorm"
+    patterns:
+      - "backend/database"
+    description: "Database query patterns"
+
+  - name: "API Endpoints"
+    type: "keyword"
+    value: "app.get|app.post|router.put"
+    patterns:
+      - "backend/express"
+      - "universal/rest-api"
+    description: "REST API patterns"
+
+  - name: "Error Handling"
+    type: "keyword"
+    value: "try|catch|throw|Error"
+    patterns:
+      - "universal/error-handling"
+    description: "Error handling patterns"
+```
+
+### Testing Triggers
+
+```yaml
+triggers:
+  - name: "Unit Tests"
+    type: "import"
+    value: "from.*jest|from.*vitest|describe|it"
+    patterns:
+      - "universal/testing/unit"
+    description: "Unit test patterns"
+
+  - name: "Integration Tests"
+    type: "path"
+    value: "**/*.integration.test.ts"
+    patterns:
+      - "universal/testing/integration"
+    description: "Integration test patterns"
+
+  - name: "E2E Tests"
+    type: "path"
+    value: "**/*.e2e.test.ts,cypress/**/*,playwright/**/*"
+    patterns:
+      - "universal/testing/e2e"
+    description: "End-to-end test patterns"
+```
+
+### Universal Triggers
+
+```yaml
+triggers:
+  - name: "TypeScript"
+    type: "fileExt"
+    value: "*.ts,*.tsx"
+    patterns:
+      - "universal/typescript"
+    description: "TypeScript patterns"
+
+  - name: "Git Workflow"
+    type: "command"
+    value: "git commit|git push|git pull"
+    patterns:
+      - "universal/git"
+    description: "Git workflow patterns"
+
+  - name: "Build Tools"
+    type: "command"
+    value: "npm|pnpm|yarn|webpack|vite"
+    patterns:
+      - "universal/build-tools"
+    description: "Build and package patterns"
+```
+
+---
+
+## Priority Order
+
+Triggers are applied in priority order:
+1. **Highest:** `fileExt` (most specific)
+2. **High:** `path` (directory context)
+3. **Medium:** `import` (code context)
+4. **Low:** `keyword` (broad matches)
+5. **Lowest:** `command` (least specific)
+
+If multiple triggers match, load all associated patterns.
+
+---
+
+## Adding New Triggers
+
+1. Identify the pattern category
+2. Determine trigger type
+3. Define pattern value
+4. Link to pattern files in `patterns/` subdirectories
+5. Add entry to appropriate section
+6. Commit with message: `docs: add trigger for [pattern]`
+
+---
+
+## Pattern Directory Structure
+
+Patterns are organized in subdirectories matching triggers:
+
+```
+patterns/
+├── frontend/
+│   ├── react/
+│   ├── styling/
+│   └── component-libs/
+├── backend/
+│   ├── express/
+│   └── database/
+└── universal/
+    ├── typescript/
+    ├── testing/
+    ├── error-handling/
+    ├── git/
+    └── build-tools/
+```
+
+Each directory contains:
+- `README.md` - Pattern documentation
+- `*.example.ts` - Code examples (optional)
+- `checklist.md` - Verification checklist (optional)
+
+---
+
+## Examples
+
+### Example 1: React Component Trigger
+
+**Condition:** User edits `src/components/Button.tsx`
+**Triggers:** `*.tsx` matches
+**Load:** `patterns/frontend/react/README.md`
+**Apply:** React component best practices to Button component
+
+### Example 2: API Endpoint Trigger
+
+**Condition:** User imports `from 'express'`
+**Triggers:** `import.*express` matches
+**Load:** `patterns/backend/express/README.md` + `patterns/universal/rest-api/README.md`
+**Apply:** Express + REST API patterns to new route
+
+### Example 3: Test File Trigger
+
+**Condition:** User creates `src/__tests__/utils.test.ts`
+**Triggers:** `*.test.ts` matches + `import jest` matches
+**Load:** `patterns/universal/testing/unit/README.md`
+**Apply:** Unit test patterns and Jest best practices
+
+---
+
+## Disabling Triggers
+
+To temporarily disable pattern auto-apply:
+
+1. Add to `state.json`: `"auto_patterns_enabled": false`
+2. Manually import patterns as needed
+3. Re-enable: `"auto_patterns_enabled": true`
+
+---
+
+## Feedback
+
+- If pattern is irrelevant, note in `state.json` to refine triggers
+- Patterns that save time: commit and document
+- Patterns that cause friction: update or disable