codymaster 4.1.4 → 4.3.0

package/skills/cm-frappe-agent/commands/frappe-erpnext.md

@@ -0,0 +1,210 @@
+---
+description: Invoke the ERPNext customizer agent for extending ERPNext with custom fields, hooks, fixtures, and module-specific customizations
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Task, TodoWrite
+argument-hint: <customization_description>
+---
+
+# ERPNext Customization
+
+You are invoking the specialized ERPNext customizer agent for extending and customizing ERPNext.
+
+## Request
+
+$ARGUMENTS
+
+## Agent Invocation
+
+Use the Task tool to spawn the `frappe-fullstack:erpnext-customizer` agent with the following configuration:
+
+**IMPORTANT:** The agent name MUST be fully qualified: `frappe-fullstack:erpnext-customizer`
+
+### Agent Prompt Template
+
+```
+You are customizing ERPNext for specific business requirements.
+
+## Task
+{user's customization description}
+
+## Context
+- This is ERPNext customization (not core modification)
+- All changes should be in a custom app
+- Use hooks, custom fields, and fixtures
+
+## Your Responsibilities
+
+1. **Analyze the Customization**
+   - Which ERPNext DocTypes are affected?
+   - What custom fields are needed?
+   - What hooks/events to intercept?
+   - What workflows to implement?
+
+2. **Explore Existing Patterns**
+   - Check how ERPNext handles similar cases
+   - Find extension points in ERPNext code
+   - Identify reusable utilities
+
+3. **Implement the Customization**
+   - Create custom fields via fixtures
+   - Add hooks in hooks.py
+   - Write override functions
+   - Set up workflows if needed
+
+4. **Ensure Portability**
+   - Export as fixtures
+   - Document the customization
+   - Handle ERPNext upgrades gracefully
+
+## Output Requirements
+- Custom field definitions (fixtures)
+- hooks.py configuration
+- Override functions
+- Workflow definitions (if applicable)
+- Installation/export commands
+```
+
+## Capabilities
+
+The erpnext-customizer agent excels at:
+
+### Custom Fields
+```python
+# In install.py
+from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
+
+custom_fields = {
+    "Sales Invoice": [
+        {
+            "fieldname": "custom_channel",
+            "label": "Sales Channel",
+            "fieldtype": "Link",
+            "options": "Sales Channel",
+            "insert_after": "customer"
+        }
+    ]
+}
+create_custom_fields(custom_fields)
+```
+
+### Document Hooks
+```python
+# hooks.py
+doc_events = {
+    "Sales Invoice": {
+        "validate": "my_app.overrides.sales_invoice.validate",
+        "on_submit": "my_app.overrides.sales_invoice.on_submit"
+    }
+}
+```
+
+### Override Class
+```python
+# hooks.py
+override_doctype_class = {
+    "Sales Invoice": "my_app.overrides.CustomSalesInvoice"
+}
+```
+
+### Fixtures
+```python
+# hooks.py
+fixtures = [
+    {"dt": "Custom Field", "filters": [["module", "=", "My App"]]},
+    {"dt": "Property Setter", "filters": [["module", "=", "My App"]]},
+    {"dt": "Workflow", "filters": [["name", "=", "My Workflow"]]}
+]
+```
+
+### Workflows
+```python
+workflow = {
+    "doctype": "Workflow",
+    "name": "Sales Order Approval",
+    "document_type": "Sales Order",
+    "is_active": 1,
+    "states": [...],
+    "transitions": [...]
+}
+```
+
+## ERPNext Modules Reference
+
+| Module | Key DocTypes |
+|--------|-------------|
+| Accounts | Sales Invoice, Purchase Invoice, Payment Entry, GL Entry |
+| Stock | Stock Entry, Delivery Note, Purchase Receipt, Item |
+| Selling | Quotation, Sales Order, Customer |
+| Buying | Purchase Order, Supplier, RFQ |
+| Manufacturing | BOM, Work Order, Job Card |
+| HR | Employee, Salary Slip, Leave Application |
+| CRM | Lead, Opportunity |
+| Projects | Project, Task, Timesheet |
+| Assets | Asset, Depreciation |
+
+## Common Customizations
+
+1. **"Add custom field to Sales Invoice for tracking"**
+   → Custom field definition + fixture
+
+2. **"Validate credit limit before Sales Order submission"**
+   → Hook on before_submit
+
+3. **"Auto-create Task when Opportunity is won"**
+   → Hook on on_update with status check
+
+4. **"Custom approval workflow for Purchase Orders"**
+   → Workflow definition + custom fields for approvers
+
+5. **"Add custom report for sales by channel"**
+   → Script report with custom query
+
+6. **"Modify print format to include custom fields"**
+   → Custom print format template
+
+## Tools Available to Agent
+
+- **Glob**: Find ERPNext and custom app files
+- **Grep**: Search ERPNext patterns
+- **Read**: Read ERPNext source for extension points
+- **Write**: Create override files
+- **Edit**: Modify hooks.py, fixtures
+- **Bash**: Export fixtures, run commands
+
+## File Locations
+
+```
+my_app/
+├── hooks.py                    # Hook configuration
+├── fixtures/                   # Exported fixtures
+│   ├── custom_field.json
+│   └── property_setter.json
+├── install.py                  # Post-install setup
+└── my_module/
+    └── overrides/
+        ├── sales_invoice.py    # SI overrides
+        └── sales_order.py      # SO overrides
+```
+
+## Post-Implementation
+
+1. **Export Fixtures**
+   ```bash
+   bench --site <site> export-fixtures --app my_app
+   ```
+
+2. **Install/Reinstall App**
+   ```bash
+   bench --site <site> install-app my_app
+   # or
+   bench --site <site> migrate
+   ```
+
+3. **Clear Cache**
+   ```bash
+   bench --site <site> clear-cache
+   ```
+
+4. **Test Customization**
+   - Verify custom fields appear
+   - Test hook functions
+   - Validate workflow transitions

package/skills/cm-frappe-agent/commands/frappe-fix.md

@@ -0,0 +1,59 @@
+---
+description: Fix Frappe/ERPNext bugs with a structured loop - reproduce, diagnose, fix, verify, document. Unlike debug (analysis-only), this actually applies fixes.
+allowed-tools: Bash, Read, Write, Edit, Grep, Glob
+argument-hint: <error_description_or_issue>
+---
+
+# Fix Frappe Bug
+
+Apply a structured bug fix following the mandatory loop: reproduce → diagnose → fix → verify → document.
+
+## Arguments
+
+Parse the user's input: $ARGUMENTS
+
+## Process
+
+### Step 1: Invoke Fixer Agent
+
+Delegate to `frappe-fixer` agent with the issue details.
+
+**Agent Prompt:**
+```
+You are fixing a Frappe/ERPNext bug.
+
+## Issue
+{user's error or issue description}
+
+## Context
+- Working directory: {current directory}
+- Follow the mandatory FIX LOOP: reproduce → diagnose → hypothesize → fix → verify → document
+
+## Requirements
+1. REPRODUCE the bug first — confirm it exists
+2. DIAGNOSE the root cause — not just symptoms
+3. HYPOTHESIZE the minimal fix
+4. APPLY the fix
+5. VERIFY it works and no regressions
+6. DOCUMENT what was fixed and why
+```
+
+### Step 2: Verify Fix
+
+After the fixer agent completes:
+```bash
+# Run tests
+bench --site <site> run-tests --app <app> --failfast
+
+# Clear cache
+bench --site <site> clear-cache
+
+# Check logs
+tail -20 logs/frappe.log | grep -i error
+```
+
+### Integration
+
+- If analysis is needed first → use `frappe-debug` command (delegates to debugger)
+- If fix requires schema changes → the fixer will coordinate with `doctype-architect`
+- If fix is on a remote site → the fixer will coordinate with `frappe-remote-ops`

package/skills/cm-frappe-agent/commands/frappe-frontend.md

@@ -0,0 +1,210 @@
+---
+description: Invoke the Frappe frontend agent for client-side JavaScript development including form scripts, dialogs, list views, and UI customization
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Task, TodoWrite
+argument-hint: <task_description>
+---
+
+# Frappe Frontend Development
+
+You are invoking the specialized Frappe frontend agent for client-side JavaScript development.
+
+## Request
+
+$ARGUMENTS
+
+## Agent Invocation
+
+Use the Task tool to spawn the `frappe-fullstack:frappe-frontend` agent with the following configuration:
+
+**IMPORTANT:** The agent name MUST be fully qualified: `frappe-fullstack:frappe-frontend`
+
+### Agent Prompt Template
+
+```
+You are working on a Frappe/ERPNext frontend task.
+
+## Task
+{user's task description}
+
+## Context
+- Working directory: {current directory}
+- This is client-side JavaScript for Frappe Desk
+
+## Your Responsibilities
+
+1. **Analyze the Request**
+   - Understand what UI/UX functionality is needed
+   - Identify which DocTypes and forms are involved
+   - Determine if this is form script, dialog, or list customization
+
+2. **Explore the Codebase**
+   - Find existing client scripts for patterns
+   - Check for reusable dialog patterns
+   - Identify existing UI conventions
+
+3. **Implement the Solution**
+   - Write clean, well-documented JavaScript
+   - Follow Frappe client-side conventions
+   - Handle async operations properly
+   - Include proper error handling and user feedback
+
+4. **Provide Complete Code**
+   - Form event handlers (refresh, validate, field changes)
+   - Custom buttons and actions
+   - Dialogs and prompts
+   - frappe.call for server communication
+
+## Output Requirements
+- Provide complete, working JavaScript code
+- Include file paths (doctype.js location)
+- Explain any server-side APIs needed
+- Note if bench build is required
+```
+
+## Capabilities
+
+The frappe-frontend agent excels at:
+
+### Form Scripts
+```javascript
+frappe.ui.form.on('My DocType', {
+    refresh: function(frm) {
+        // Add buttons, toggle fields
+    },
+    validate: function(frm) {
+        // Client-side validation
+    },
+    field_name: function(frm) {
+        // Field change handler
+    }
+});
+```
+
+### Child Table Events
+```javascript
+frappe.ui.form.on('My DocType Item', {
+    qty: function(frm, cdt, cdn) {
+        let row = locals[cdt][cdn];
+        row.amount = row.qty * row.rate;
+        frm.refresh_field('items');
+    }
+});
+```
+
+### Custom Buttons
+```javascript
+frm.add_custom_button(__('Action'), function() {
+    // Button logic
+}, __('Actions'));
+```
+
+### Dialogs
+```javascript
+let dialog = new frappe.ui.Dialog({
+    title: __('My Dialog'),
+    fields: [
+        {fieldname: 'field1', fieldtype: 'Data', label: 'Field 1'}
+    ],
+    primary_action: function(values) {
+        // Handle submission
+    }
+});
+dialog.show();
+```
+
+### Server Calls
+```javascript
+frappe.call({
+    method: 'myapp.api.my_function',
+    args: { param: value },
+    freeze: true,
+    callback: function(r) {
+        // Handle response
+    }
+});
+```
+
+### Field Manipulation
+```javascript
+// Show/hide
+frm.toggle_display('fieldname', condition);
+
+// Required
+frm.toggle_reqd('fieldname', condition);
+
+// Read-only
+frm.set_df_property('fieldname', 'read_only', 1);
+
+// Set query for Link field
+frm.set_query('customer', function() {
+    return { filters: { status: 'Active' } };
+});
+```
+
+## Common Tasks
+
+1. **"Add button to create follow-up task"**
+   → Custom button with dialog for task details
+
+2. **"Show/hide fields based on document type selection"**
+   → Field change handler with toggle_display
+
+3. **"Auto-calculate totals when qty or rate changes"**
+   → Child table field events
+
+4. **"Validate that end date is after start date"**
+   → validate event with frappe.throw
+
+5. **"Fetch customer details when customer is selected"**
+   → Field change with frappe.call
+
+6. **"Add custom filter to link field"**
+   → set_query with dynamic filters
+
+## Tools Available to Agent
+
+- **Glob**: Find JavaScript files
+- **Grep**: Search for existing patterns
+- **Read**: Read existing client scripts
+- **Write**: Create new files
+- **Edit**: Modify existing code
+- **Bash**: Check file structure, run bench build
+
+## File Locations
+
+```
+my_app/
+└── my_module/
+    └── doctype/
+        └── my_doctype/
+            └── my_doctype.js    # Form script
+```
+
+For list view:
+```
+my_app/
+└── my_module/
+    └── doctype/
+        └── my_doctype/
+            └── my_doctype_list.js    # List script
+```
+
+## Post-Implementation
+
+After the agent completes:
+
+1. **Build Assets** (if new files created)
+   ```bash
+   bench build --app my_app
+   ```
+
+2. **Clear Cache**
+   ```bash
+   bench --site <site> clear-cache
+   ```
+
+3. **Hard Refresh Browser**
+   - Ctrl+Shift+R to reload without cache
+
+4. **Check Browser Console**
+   - F12 → Console for JavaScript errors

package/skills/cm-frappe-agent/commands/frappe-fullstack.md

@@ -0,0 +1,243 @@
+---
+description: Invoke multiple Frappe agents in parallel for full-stack development - coordinates backend, frontend, and architecture agents for complete feature implementation
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Task, TodoWrite, AskUserQuestion
+argument-hint: <feature_description>
+---
+
+# Frappe Full-Stack Development
+
+Orchestrate multiple specialized agents to build complete features across the full Frappe stack.
+
+## Request
+
+$ARGUMENTS
+
+## Orchestration Strategy
+
+This command coordinates multiple agents working in parallel for comprehensive feature development.
+
+### Phase 1: Understanding & Planning
+
+First, understand the scope:
+
+1. **Analyze the Feature Request**
+   - What data needs to be stored? (DocType design)
+   - What backend logic is needed? (Controllers, APIs)
+   - What UI/UX is required? (Form scripts, dialogs)
+   - Is ERPNext integration needed? (Customizations, hooks)
+
+2. **Create Todo List**
+   Use TodoWrite to track:
+   - [ ] DocType/data model design
+   - [ ] Backend implementation
+   - [ ] Frontend implementation
+   - [ ] Integration/hooks (if needed)
+   - [ ] Testing
+
+### Phase 2: Parallel Agent Invocation
+
+Launch agents in parallel using multiple Task tool calls in a single message.
+
+**IMPORTANT:** Agent names MUST be fully qualified with plugin prefix:
+- `frappe-fullstack:doctype-architect`
+- `frappe-fullstack:frappe-backend`
+- `frappe-fullstack:frappe-frontend`
+- `frappe-fullstack:erpnext-customizer`
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    PARALLEL EXECUTION                        │
+├─────────────────┬─────────────────┬─────────────────────────┤
+│ frappe-fullstack│ frappe-fullstack│ frappe-fullstack:       │
+│ :doctype-       │ :frappe-backend │ frappe-frontend         │
+│ architect       │                 │                         │
+│                 │                 │                         │
+│ • Design schema │ • Controllers   │ • Form scripts          │
+│ • Field types   │ • APIs          │ • Dialogs               │
+│ • Relationships │ • Validation    │ • Field handlers        │
+│ • Permissions   │ • Background    │ • Custom buttons        │
+└─────────────────┴─────────────────┴─────────────────────────┘
+```
+
+### Agent Prompts
+
+#### DocType Architect Agent
+```
+Design the data model for: {feature description}
+
+Requirements:
+- Identify all entities/DocTypes needed
+- Define fields with appropriate types
+- Establish relationships (Link, Table)
+- Set up naming conventions
+- Define permissions
+
+Output:
+- Complete DocType JSON(s)
+- Relationship diagram (text)
+- Field specifications
+```
+
+#### Backend Agent
+```
+Implement server-side logic for: {feature description}
+
+The DocType structure is: {from architect agent or existing}
+
+Requirements:
+- Controller methods (validate, lifecycle hooks)
+- Whitelisted APIs for frontend
+- Database queries if complex
+- Background jobs if long-running
+- Email/notification logic
+
+Output:
+- Complete Python controller
+- API functions
+- hooks.py updates if needed
+```
+
+#### Frontend Agent
+```
+Implement client-side functionality for: {feature description}
+
+The DocType and APIs are: {from other agents or existing}
+
+Requirements:
+- Form script with event handlers
+- Custom buttons for actions
+- Dialogs for user input
+- Field visibility/requirement logic
+- frappe.call to backend APIs
+
+Output:
+- Complete JavaScript form script
+- Any list view customizations
+- Dialog implementations
+```
+
+### Phase 3: Integration
+
+After parallel agents complete:
+
+1. **Merge Outputs**
+   - Combine all generated code
+   - Resolve any conflicts
+   - Ensure API names match between frontend/backend
+
+2. **Add ERPNext Integration** (if needed)
+   Spawn `frappe-fullstack:erpnext-customizer` agent for:
+   - Custom fields on stock DocTypes
+   - Hooks configuration
+   - after_migrate setup (preferred over fixtures)
+
+3. **Create Files**
+   Write all files to appropriate locations:
+   ```
+   my_app/
+   └── my_module/
+       └── doctype/
+           └── my_doctype/
+               ├── my_doctype.json    # From architect
+               ├── my_doctype.py      # From backend
+               ├── my_doctype.js      # From frontend
+               └── test_my_doctype.py # Tests
+   ```
+
+### Phase 4: Finalization
+
+1. **Update hooks.py** if needed
+2. **Run Migration**
+   ```bash
+   bench --site <site> migrate
+   ```
+3. **Build Assets**
+   ```bash
+   bench build --app <app>
+   ```
+4. **Clear Cache**
+   ```bash
+   bench --site <site> clear-cache
+   ```
+
+## Example Workflows
+
+### Example 1: "Create a customer feedback system"
+
+**Parallel Agents:**
+
+1. **doctype-architect**: Designs "Customer Feedback" DocType
+   - Fields: customer, rating, category, description, status, assigned_to
+   - Child table for follow-up actions
+
+2. **frappe-backend**: Implements
+   - Validation (rating 1-5)
+   - Auto-assign based on category
+   - Email notification on submission
+   - API to get feedback statistics
+
+3. **frappe-frontend**: Creates
+   - Star rating widget
+   - Category-based field visibility
+   - "Resolve" button for assigned user
+   - Dashboard statistics display
+
+### Example 2: "Add approval workflow to purchase requests"
+
+**Parallel Agents:**
+
+1. **doctype-architect**: Modifies/creates
+   - Approval fields (approved_by, approval_date, rejection_reason)
+   - Status field with workflow states
+
+2. **frappe-backend**: Implements
+   - Permission checks for approval
+   - Email to approver on submission
+   - Budget validation before approval
+   - API for bulk approval
+
+3. **frappe-frontend**: Creates
+   - Approve/Reject buttons (conditional)
+   - Rejection reason dialog
+   - Status indicator colors
+   - Pending approvals list filter
+
+4. **erpnext-customizer** (if extending ERPNext):
+   - Custom fields on Material Request
+   - Workflow definition
+   - Role permissions
+
+## Agent Coordination Tips
+
+1. **Share Context**: Pass DocType definitions from architect to other agents
+2. **Consistent Naming**: Ensure API method names match between frontend/backend
+3. **Handle Dependencies**: Backend APIs must exist before frontend can call them
+4. **Test Incrementally**: Verify each layer works before integrating
+
+## Tools Available
+
+| Tool | Purpose |
+|------|---------|
+| Task | Spawn specialized agents |
+| TodoWrite | Track progress |
+| Glob | Find files |
+| Grep | Search code |
+| Read | Read existing code |
+| Write | Create files |
+| Edit | Modify files |
+| Bash | Run commands |
+| AskUserQuestion | Clarify requirements |
+
+## Output Checklist
+
+After completion, verify:
+
+- [ ] DocType JSON created/modified
+- [ ] Python controller implemented
+- [ ] JavaScript form script implemented
+- [ ] APIs accessible from frontend
+- [ ] hooks.py updated (if needed)
+- [ ] Migration successful
+- [ ] Assets built
+- [ ] Cache cleared
+- [ ] Feature tested in browser