@jakkrichm/create-nexus-devflow 2.0.0

package/template/.agents/skills/prp-dev-multiplatform/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: prp-dev-multiplatform
+description: Intelligent platform router for PRP development. Automatically detects whether the project is FastAPI, Odoo, or PHP and provides guidance on which specific skill to use.
+---
+
+# 🚦 PRP Dev – Platform Router (Pure Agentic)
+
+This Skill functions as an **"Intelligent Receptionist"**, helping detect the technology powering your current project and directing other AIs (or myself) to adopt the appropriate specialized Skill for the job.
+
+## 🔍 Platform Detection Logic
+
+When kick-starting a new task or if the environment is ambiguous, I will scan the files as follows:
+
+### 1. 🐍 FastAPI
+- **Check**: `main.py`, `app.py` featuring `from fastapi import FastAPI`, or a `requirements.txt` file listing `fastapi`.
+- **Recommended Skill**: `prp-dev-fastapi`
+
+### 2. 📦 Odoo (ERP)
+- **Check**: The `addons/` folder, `__manifest__.py` (for versions 13+), or `__openerp__.py` (for version 8).
+- **Recommended Skill**: `prp-dev-odoo`
+
+### 3. 🐘 PHP (CI/Yii)
+- **Check**: The `application/` folder (CodeIgniter) or the `vendor/yiisoft/` folder (Yii).
+- **Recommended Skill**: `prp-dev-php`
+
+---
+
+## 🛠️ Action Flow
+
+Upon detecting a Platform:
+1. **Notification**: I will inform you of the detected Stack (e.g., "Detected: Odoo 13 module").
+2. **Mode Switch**: I will instantly harness the knowledge from the relevant specialized Skill to plan (`/30-Plan`) and write code (`/40-Implement`).
+3. **Fallback**: If an unrecognized Stack is spotted, I will ask you for details or default to the standard **Generic Python/JS** pattern.
+
+---
+*Developed for Nexus-DevFlow — Hybrid Development Support*

package/template/.agents/skills/prp-dev-odoo/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: prp-dev-odoo
+description: Comprehensive skill for Odoo development following the PRP Pure Agentic workflow. Supports Odoo 8 and Odoo 13+ patterns, model/view/controller architecture, and automated validation in a Zero-Script environment.
+---
+
+# 📦 PRP Dev – Odoo (Pure Agentic)
+
+This Skill operates to facilitate feature development on **Odoo** (ERP) in obedience to PRP Framework standards. It encompasses both Legacy (Odoo 8) and Modern (Odoo 13+) versions, enforcing correct Inheritance practices and optimal Security measures.
+
+## 🎯 Scope of Work
+Apply this Skill when:
+- **Module Dev**: Building or revising Odoo Modules (Models, Views, Controllers, Wizards).
+- **Migration/Fix**: Squashing Bugs or ameliorating features within Odoo 8 and 13+.
+- **Security**: Configuring Access Rights (CSV) and Record Rules (XML).
+- **Workflow**: Engaging in Odoo-related tasks throughout its lifecycle.
+
+---
+
+## 1. 🔍 Platform & Version Detection
+Check the Odoo environment preceding any actions:
+1. **Odoo 8**: Search for `__openerp__.py` or the `openerp` namespace.
+2. **Odoo 13+**: Search for `__manifest__.py` or the `odoo` namespace.
+3. **Module Structure**: Inspect directories like `addons/` or `models/`, `views/`.
+
+---
+
+## 2. 🧱 Implementation Guidelines
+
+### Naming Conventions
+- **Module/Model**: `snake_case` (e.g., `sale_order_line`)
+- **Class**: `PascalCase` (e.g., `SaleOrderLine`)
+- **Fields**: `snake_case`
+
+### Persistence Patterns (Inheritance)
+- **Model**: Leverage `_inherit` to extend an existing model's capability.
+- **View**: Always utilize `<xpath expr="..." position="...">` to adjust existing UI to mitigate conflict.
+
+### Security (Mandatory)
+Every time a new Model is fabricated, it must include:
+1. `security/ir.model.access.csv`: Group-level access rights.
+2. `security/ir.rule.xml`: (If necessary) Record visibility specifications (e.g., visible only to the record owner).
+
+---
+
+## 3. 🛡️ Pattern References
+
+| Version | Root Header | Namespace | Decorators |
+|:---|:---|:---|:---|
+| **Odoo 8** | `<openerp>` | `from openerp import ...` | `@api.one`, `@api.multi` |
+| **Odoo 13+** | `<odoo>` | `from odoo import ...` | `@api.model`, `@api.depends` |
+
+---
+
+## 🔄 PRP Workflow Integration (Zero-Script)
+For each Task, the Agent must adhere to these principles:
+
+### Phase: Planning (/30-Plan)
+- Designate the files to be created/modified in the `File & Directory Index`.
+- Formulate a `Validation Loop`:
+    - **Step 1**: Lint (flake8/pylint-odoo)
+    - **Step 2**: Odoo Test (`--test-enable` / `--init` module)
+
+### Phase: Implement (/40-Implement)
+- Proceed with subtasks sequentially and record status in `implement.md`.
+- **Gotcha**: Be mindful of Odoo's Caching. Following any Python modifications, inevitably Restart the service and update the Module.
+
+---
+
+## 🧪 Testing & Validation
+- **Common Case**: Utilize `TransactionCase` to execute Business Logic Tests.
+- **UI Check**: Propose instructions for verification via a Browser inside `verify.md`.

package/template/.agents/skills/prp-dev-php/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: prp-dev-php
+description: Comprehensive skill for PHP development following the PRP Pure Agentic workflow. Supports CodeIgniter 3 and Yii 2, with MVC patterns and automated validation loops in a Zero-Script environment.
+---
+
+# 🐘 PRP Dev – PHP (Pure Agentic)
+
+This Skill empowers feature development on **PHP** conforming to the PRP Framework standards, focusing principally on CodeIgniter 3 (Legacy) and Yii Framework 2 (Modern). It fully addresses MVC operations alongside fundamental security fortifications.
+
+## 🎯 Scope of Work
+Apply this Skill when:
+- **Framework Dev**: Constructing or mending Controllers, Models, and Views.
+- **Legacy Support**: Improving CodeIgniter 3 codebases for better security and structure.
+- **Modern PHP**: Advancing Yii 2 exploiting ActiveRecord and Dependency Injection.
+- **Workflow**: Doing Task-related work pertinent to PHP Apps.
+
+---
+
+## 1. 🔍 Framework Detection
+Probe the environment prior to starting work:
+1. **CodeIgniter 3**: Probe for `application/config/config.php` or `system/`.
+2. **Yii 2**: Probe for `vendor/yiisoft/yii2` or `config/web.php`.
+3. **Composer**: Look over `composer.json` for PHP versions and Dependencies.
+
+---
+
+## 2. 🏛️ Implementation Patterns
+
+### CodeIgniter 3 (The Singleton Pattern)
+- **Namespacing**: Frequently lacks namespaces (Global usage).
+- **Loading**: Implements `$this->load->model('...')` or `$this->load->view('...')`.
+- **Security**: Compulsory check: `defined('BASEPATH') OR exit('...');` required universally at the top of files.
+
+### Yii Framework 2 (The Component Pattern)
+- **ActiveRecord**: Fulfills Querying through Model Classes (e.g., `User::find()`).
+- **Namespacing**: Extensively integrates PSR-4 Namespacing.
+- **Views**: Incorporates `Html::encode()` alongside `$this->render()`.
+
+---
+
+## 🛡️ Security Best Practices
+- **Prepared Statements**: Mandate using the Query Builder or ORM. Raw SQL accepting direct Variables is strictly forbidden.
+- **Input Validation**: Abide by Framework Validation (CI Form Validation / Yii Rules).
+- **Output Escaping**: Obviate XSS attacks by Encoding data before displaying it on HTML.
+
+---
+
+## 🔄 PRP Workflow Integration (Zero-Script)
+For each Task, the Agent must adhere to these principles:
+
+### Phase: Planning (/30-Plan)
+- Designate the files for modification and outline Validation procedures (e.g., executing `phpunit`).
+
+### Phase: Implement (/40-Implement)
+- Proceed with subtasks sequentially and capture real progress in `implement.md`.
+- Chronicle implementation and verification-relevant notes in `implement.md` and `verify.md` first.
+
+---
+
+## 🧪 Testing & Validation
+- **Unit Testing**: Employ `PHPUnit` or any pre-installed testing framework within the project.
+- **Command Line**: Tests typically run via `./vendor/bin/phpunit` or specialized framework commands.
+- **Manual Check**: Specify manual verification steps in `verify.md`.

package/template/.agents/skills/prp-sa-ba/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: prp-sa-ba
+description: Assist SA/BA in this PRP-based Pure Agentic project with requirement analysis, spec refinement, and maintaining INITIAL.md. Use whenever the user is acting as SA/BA, defining tasks, or discussing project overview.
+---
+
+# 📋 PRP SA/BA Workflow (Pure Agentic)
+
+This Skill is tailored to assist users playing the role of an **SA/BA/PO** by collecting requirements and setting up specs so that the AI can work precisely thereafter in accordance with Pure Agentic Framework standards.
+
+## 🎯 Scope of Work
+Apply this Skill when:
+- **Requirement Analysis**: Transcribing Raw requirements into an actionable plan.
+- **Spec Refinement**: Formatting or fine-tuning `spec.md` located in the task folder.
+- **Project Indexing**: Operating and updating `INITIAL.md` ensuring it acts as an up-to-date index.
+- **Flow Coordination**: Recommending ensuing actions within the Workflow (Issue -> Spec -> Plan -> Code -> Verify).
+
+---
+
+## 1. 📂 Staging to Spec (Phase: New Task)
+Commencing a new task:
+1. **Pickup from Staging**: Monitor for specific files localized inside `devflow/issues/` (Staging Area).
+2. **Standardize**: Exploit Issue data to instigate a task directory under `devflow/runs/{ID}-{slug}/`.
+3. **Core Files**: Lay down standard requisite AI files:
+   - `spec.md`: Elaborate technical nuances coupled with Acceptance Criteria.
+   - `define.md` / `spec.md` metadata sections: informative context relating to categories, priority, and complexity.
+
+---
+
+## 2. 🧠 Requirement Refining
+Aid the SA/BA in finalizing needs thoroughly prior to writing any Code:
+- **Dimension 360**: Question elements about Edge Cases, UX, Security, and Technical Impacts.
+- **Measurable Goals**: Tweak Acceptance Criteria causing them to be quantitatively tangible (averting phrases like "make it good").
+- **Metadata Tuning**: Harmonize Complexity and Priority to resonate closely alongside the veritable effort needed.
+
+---
+
+## 3. 📑 Maintaining INITIAL.md
+Act as custodian of the "Home Page of Project" warranting it persists as the quintessential Source of Truth invariably:
+- **Indexing**: During the inception or completion of a Task, append a link right into the `Active Specs & Tasks` division.
+- **Stack Status**: Maintain the pertinent Technical Stack information actively updated if modifications transpire.
+- **Allowed Commands**: Audit alongside updating explicit lists highlighting commands currently actionable by the AI.
+
+---
+
+## 🔄 Workflow Guidance (Next Steps)
+Advocate relevant commands following the DevFlow 2.0 hierarchy:
+1. **Planning**: Once a spec matures sufficiently, advise executing `/30-Plan {ID}`.
+2. **Implementation**: After the plan is ready, endorse launching `/40-Implement {ID}`.
+3. **Review**: After implementation evidence exists, point the user to `/50-Verify {ID}`, then `/60-Report {ID}`, and finally `/70-Release {ID}` when release execution is still needed.
+
+---
+*Note: This skill synergizes most efficiently running alongside the Agent Persona `requirements-engineer`.*

package/template/.agents/skills/python-patterns/SKILL.md

@@ -0,0 +1,441 @@
+---
+name: python-patterns
+description: Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# Python Patterns
+
+> Python development principles and decision-making for 2025.
+> **Learn to THINK, not memorize patterns.**
+
+---
+
+## ⚠️ How to Use This Skill
+
+This skill teaches **decision-making principles**, not fixed code to copy.
+
+- ASK user for framework preference when unclear
+- Choose async vs sync based on CONTEXT
+- Don't default to same framework every time
+
+---
+
+## 1. Framework Selection (2025)
+
+### Decision Tree
+
+```
+What are you building?
+│
+├── API-first / Microservices
+│   └── FastAPI (async, modern, fast)
+│
+├── Full-stack web / CMS / Admin
+│   └── Django (batteries-included)
+│
+├── Simple / Script / Learning
+│   └── Flask (minimal, flexible)
+│
+├── AI/ML API serving
+│   └── FastAPI (Pydantic, async, uvicorn)
+│
+└── Background workers
+    └── Celery + any framework
+```
+
+### Comparison Principles
+
+| Factor | FastAPI | Django | Flask |
+|--------|---------|--------|-------|
+| **Best for** | APIs, microservices | Full-stack, CMS | Simple, learning |
+| **Async** | Native | Django 5.0+ | Via extensions |
+| **Admin** | Manual | Built-in | Via extensions |
+| **ORM** | Choose your own | Django ORM | Choose your own |
+| **Learning curve** | Low | Medium | Low |
+
+### Selection Questions to Ask:
+1. Is this API-only or full-stack?
+2. Need admin interface?
+3. Team familiar with async?
+4. Existing infrastructure?
+
+---
+
+## 2. Async vs Sync Decision
+
+### When to Use Async
+
+```
+async def is better when:
+├── I/O-bound operations (database, HTTP, file)
+├── Many concurrent connections
+├── Real-time features
+├── Microservices communication
+└── FastAPI/Starlette/Django ASGI
+
+def (sync) is better when:
+├── CPU-bound operations
+├── Simple scripts
+├── Legacy codebase
+├── Team unfamiliar with async
+└── Blocking libraries (no async version)
+```
+
+### The Golden Rule
+
+```
+I/O-bound → async (waiting for external)
+CPU-bound → sync + multiprocessing (computing)
+
+Don't:
+├── Mix sync and async carelessly
+├── Use sync libraries in async code
+└── Force async for CPU work
+```
+
+### Async Library Selection
+
+| Need | Async Library |
+|------|---------------|
+| HTTP client | httpx |
+| PostgreSQL | asyncpg |
+| Redis | aioredis / redis-py async |
+| File I/O | aiofiles |
+| Database ORM | SQLAlchemy 2.0 async, Tortoise |
+
+---
+
+## 3. Type Hints Strategy
+
+### When to Type
+
+```
+Always type:
+├── Function parameters
+├── Return types
+├── Class attributes
+├── Public APIs
+
+Can skip:
+├── Local variables (let inference work)
+├── One-off scripts
+├── Tests (usually)
+```
+
+### Common Type Patterns
+
+```python
+# These are patterns, understand them:
+
+# Optional → might be None
+from typing import Optional
+def find_user(id: int) -> Optional[User]: ...
+
+# Union → one of multiple types
+def process(data: str | dict) -> None: ...
+
+# Generic collections
+def get_items() -> list[Item]: ...
+def get_mapping() -> dict[str, int]: ...
+
+# Callable
+from typing import Callable
+def apply(fn: Callable[[int], str]) -> str: ...
+```
+
+### Pydantic for Validation
+
+```
+When to use Pydantic:
+├── API request/response models
+├── Configuration/settings
+├── Data validation
+├── Serialization
+
+Benefits:
+├── Runtime validation
+├── Auto-generated JSON schema
+├── Works with FastAPI natively
+└── Clear error messages
+```
+
+---
+
+## 4. Project Structure Principles
+
+### Structure Selection
+
+```
+Small project / Script:
+├── main.py
+├── utils.py
+└── requirements.txt
+
+Medium API:
+├── app/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── models/
+│   ├── routes/
+│   ├── services/
+│   └── schemas/
+├── tests/
+└── pyproject.toml
+
+Large application:
+├── src/
+│   └── myapp/
+│       ├── core/
+│       ├── api/
+│       ├── services/
+│       ├── models/
+│       └── ...
+├── tests/
+└── pyproject.toml
+```
+
+### FastAPI Structure Principles
+
+```
+Organize by feature or layer:
+
+By layer:
+├── routes/ (API endpoints)
+├── services/ (business logic)
+├── models/ (database models)
+├── schemas/ (Pydantic models)
+└── dependencies/ (shared deps)
+
+By feature:
+├── users/
+│   ├── routes.py
+│   ├── service.py
+│   └── schemas.py
+└── products/
+    └── ...
+```
+
+---
+
+## 5. Django Principles (2025)
+
+### Django Async (Django 5.0+)
+
+```
+Django supports async:
+├── Async views
+├── Async middleware
+├── Async ORM (limited)
+└── ASGI deployment
+
+When to use async in Django:
+├── External API calls
+├── WebSocket (Channels)
+├── High-concurrency views
+└── Background task triggering
+```
+
+### Django Best Practices
+
+```
+Model design:
+├── Fat models, thin views
+├── Use managers for common queries
+├── Abstract base classes for shared fields
+
+Views:
+├── Class-based for complex CRUD
+├── Function-based for simple endpoints
+├── Use viewsets with DRF
+
+Queries:
+├── select_related() for FKs
+├── prefetch_related() for M2M
+├── Avoid N+1 queries
+└── Use .only() for specific fields
+```
+
+---
+
+## 6. FastAPI Principles
+
+### async def vs def in FastAPI
+
+```
+Use async def when:
+├── Using async database drivers
+├── Making async HTTP calls
+├── I/O-bound operations
+└── Want to handle concurrency
+
+Use def when:
+├── Blocking operations
+├── Sync database drivers
+├── CPU-bound work
+└── FastAPI runs in threadpool automatically
+```
+
+### Dependency Injection
+
+```
+Use dependencies for:
+├── Database sessions
+├── Current user / Auth
+├── Configuration
+├── Shared resources
+
+Benefits:
+├── Testability (mock dependencies)
+├── Clean separation
+├── Automatic cleanup (yield)
+```
+
+### Pydantic v2 Integration
+
+```python
+# FastAPI + Pydantic are tightly integrated:
+
+# Request validation
+@app.post("/users")
+async def create(user: UserCreate) -> UserResponse:
+    # user is already validated
+    ...
+
+# Response serialization
+# Return type becomes response schema
+```
+
+---
+
+## 7. Background Tasks
+
+### Selection Guide
+
+| Solution | Best For |
+|----------|----------|
+| **BackgroundTasks** | Simple, in-process tasks |
+| **Celery** | Distributed, complex workflows |
+| **ARQ** | Async, Redis-based |
+| **RQ** | Simple Redis queue |
+| **Dramatiq** | Actor-based, simpler than Celery |
+
+### When to Use Each
+
+```
+FastAPI BackgroundTasks:
+├── Quick operations
+├── No persistence needed
+├── Fire-and-forget
+└── Same process
+
+Celery/ARQ:
+├── Long-running tasks
+├── Need retry logic
+├── Distributed workers
+├── Persistent queue
+└── Complex workflows
+```
+
+---
+
+## 8. Error Handling Principles
+
+### Exception Strategy
+
+```
+In FastAPI:
+├── Create custom exception classes
+├── Register exception handlers
+├── Return consistent error format
+└── Log without exposing internals
+
+Pattern:
+├── Raise domain exceptions in services
+├── Catch and transform in handlers
+└── Client gets clean error response
+```
+
+### Error Response Philosophy
+
+```
+Include:
+├── Error code (programmatic)
+├── Message (human readable)
+├── Details (field-level when applicable)
+└── NOT stack traces (security)
+```
+
+---
+
+## 9. Testing Principles
+
+### Testing Strategy
+
+| Type | Purpose | Tools |
+|------|---------|-------|
+| **Unit** | Business logic | pytest |
+| **Integration** | API endpoints | pytest + httpx/TestClient |
+| **E2E** | Full workflows | pytest + DB |
+
+### Async Testing
+
+```python
+# Use pytest-asyncio for async tests
+
+import pytest
+from httpx import AsyncClient
+
+@pytest.mark.asyncio
+async def test_endpoint():
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.get("/users")
+        assert response.status_code == 200
+```
+
+### Fixtures Strategy
+
+```
+Common fixtures:
+├── db_session → Database connection
+├── client → Test client
+├── authenticated_user → User with token
+└── sample_data → Test data setup
+```
+
+---
+
+## 10. Decision Checklist
+
+Before implementing:
+
+- [ ] **Asked user about framework preference?**
+- [ ] **Chosen framework for THIS context?** (not just default)
+- [ ] **Decided async vs sync?**
+- [ ] **Planned type hint strategy?**
+- [ ] **Defined project structure?**
+- [ ] **Planned error handling?**
+- [ ] **Considered background tasks?**
+
+---
+
+## 11. Anti-Patterns to Avoid
+
+### ❌ DON'T:
+- Default to Django for simple APIs (FastAPI may be better)
+- Use sync libraries in async code
+- Skip type hints for public APIs
+- Put business logic in routes/views
+- Ignore N+1 queries
+- Mix async and sync carelessly
+
+### ✅ DO:
+- Choose framework based on context
+- Ask about async requirements
+- Use Pydantic for validation
+- Separate concerns (routes → services → repos)
+- Test critical paths
+
+---
+
+> **Remember**: Python patterns are about decision-making for YOUR specific context. Don't copy code—think about what serves your application best.