Initial commit

2025-11-30 08:38:44 +08:00
commit 0351cc1fd3
17 changed files with 8151 additions and 0 deletions
--- a/.claude/skills/automation-quick-fix/SKILL.md
+++ b/.claude/skills/automation-quick-fix/SKILL.md
@@ -0,0 +1,690 @@
+---
+name: automation-quick-fix
+description: Fast automation platform error resolver for Power Automate, n8n, Make, Zapier and other platforms. Handles common patterns like 401/403 auth errors, 429 throttling, and data format issues. Provides immediate fixes without deep research for well-known error patterns. Use when error matches common scenarios (status codes 401, 403, 404, 429, timeout, parse JSON failures). For complex or unknown errors, defer to automation-debugger skill. When the user outputs some code/json snippets and ask for a quick fix, this skill will provide immediate solutions.
+---
+
+# Automation Quick Fix
+
+Fast-track resolver for common automation workflow error patterns across multiple platforms with immediate, proven solutions.
+
+## Supported Platforms
+
+- **Power Automate** (Microsoft)
+- **n8n** (Open-source)
+- **Make** (formerly Integromat)
+- **Zapier**
+- **Other JSON-based workflow platforms**
+
+## Purpose
+
+Provides rapid fixes for frequently encountered automation workflow errors across all platforms:
+- Authentication errors (401/403)
+- Throttling errors (429)
+- Data format issues (JSON parsing, data transformation)
+- Timeout errors
+- Not found errors (404)
+- Basic expression/formula errors
+
+**When to use this skill**: Error matches a well-known pattern
+**When to use automation-debugger instead**: Unknown error, complex scenario, or quick fix doesn't resolve
+
+## Activation Triggers
+
+Activates for messages like:
+- "Quick fix for 429 error in SharePoint/API/webhook"
+- "Fast solution for authentication error in n8n"
+- "I'm getting throttled in Make, need immediate fix"
+- "Parse JSON is failing in Zapier, quick help"
+- "Function expects one parameter but was invoked with 2"
+- "Unable to process template language expressions"
+- "Fix this expression/filter/query/condition"
+- User provides code snippet and asks for "quick fix" or "fix this"
+- Status codes: 401, 403, 404, 429 with platform/connector context
+- Platform-specific: "n8n node error", "Make scenario failing", "Power Automate action issue"
+
+## ⚠️ IMPORTANT: Data Structure Check (NEW!)
+
+**Before applying any quick fix**, quickly verify data structures in your flow:
+
+### Quick Data Type Check
+```javascript
+// In filters/queries, check the where clause:
+
+// Array of STRINGS (primitives):
+"where": "@contains(item(), 'text')"  // ← item() without property
+
+// Array of OBJECTS:
+"where": "@contains(item()?['Name'], 'text')"  // ← item()?['Property']
+```
+
+**If your flow has data structure mismatches** (filter uses `item()` but loop uses `items('Loop')?['Property']`), this is NOT a quick fix scenario → use **automation-debugger** instead.
+
+**Quick Fix applies to**: Authentication, throttling, timeouts, parse JSON, NOT structural bugs.
+
+---
+
+## Quick Fix Patterns
+
+### Data Structure Mismatch (Quick Check - NEW!)
+
+**Pattern Recognition**:
+- Error: "Cannot evaluate property on undefined/null"
+- Loop accessing `items('Loop')?['Property']` but source is array of strings
+
+**Quick Diagnosis**:
+```javascript
+// Check your filter:
+"where": "@contains(item(), 'value')"  // ← This means array of STRINGS!
+
+// But loop tries:
+"value": "@items('Loop')?['PropertyName']"  // ← ERROR: Can't access property on string!
+```
+
+**Quick Decision**:
+- ❌ **NOT a quick fix** → Use **automation-debugger skill**
+- This requires analyzing full data flow and structure
+- Quick fix = known patterns; structural bugs = deep debugging
+
+---
+
+### Authentication Errors (401/403)
+
+**Pattern Recognition**:
+- Status: 401 or 403
+- Keywords: "unauthorized", "forbidden", "access denied"
+
+**Immediate Fix**:
+
+```json
+{
+  "actions": {
+    "Scope_With_Auth_Handling": {
+      "type": "Scope",
+      "actions": {
+        "Your_Action": {
+          "type": "ApiConnection",
+          "inputs": { /* your config */ },
+          "authentication": {
+            "type": "Raw",
+            "value": "@parameters('$connections')['shared_sharepointonline']['connectionId']"
+          }
+        }
+      }
+    },
+    "Catch_Auth_Error": {
+      "type": "Terminate",
+      "inputs": {
+        "runStatus": "Failed",
+        "runError": {
+          "code": "AuthenticationFailed",
+          "message": "Please re-authenticate the connection in Power Automate"
+        }
+      },
+      "runAfter": {
+        "Scope_With_Auth_Handling": ["Failed"]
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Copy the Scope structure above
+2. Replace "Your_Action" with your failing action
+3. Update connection name if not SharePoint
+4. Save and re-authenticate connection in Power Automate UI
+
+---
+
+### Throttling Errors (429)
+
+**Pattern Recognition**:
+- Status: 429
+- Keywords: "TooManyRequests", "throttled", "rate limit"
+
+**Immediate Fix - SharePoint/OneDrive**:
+
+```json
+{
+  "actions": {
+    "Apply_to_each_FIXED": {
+      "type": "Foreach",
+      "foreach": "@body('Get_items')?['value']",
+      "runtimeConfiguration": {
+        "concurrency": {
+          "repetitions": 1
+        }
+      },
+      "actions": {
+        "Your_API_Action": {
+          "type": "ApiConnection",
+          "inputs": { /* your config */ },
+          "runAfter": {}
+        },
+        "Delay_1_Second": {
+          "type": "Wait",
+          "inputs": {
+            "interval": {
+              "count": 1,
+              "unit": "Second"
+            }
+          },
+          "runAfter": {
+            "Your_API_Action": ["Succeeded"]
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Find your Apply to each loop
+2. Add `runtimeConfiguration.concurrency.repetitions: 1`
+3. Add Delay action after API calls (1 second for SharePoint, 3 seconds for OneDrive)
+4. Save and test
+
+**Quick calculation**:
+- SharePoint limit: 600/minute → 1-second delay = 60/minute (safe)
+- OneDrive limit: 100/minute → 3-second delay = 20/minute (safe)
+
+---
+
+### Parse JSON Failures
+
+**Pattern Recognition**:
+- Error: "InvalidTemplate", "cannot be evaluated"
+- Keywords: "Parse JSON", "dynamic content", "schema"
+
+**Immediate Fix**:
+
+```json
+{
+  "actions": {
+    "Parse_JSON_FIXED": {
+      "type": "ParseJson",
+      "inputs": {
+        "content": "@body('HTTP')",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "id": {"type": "string"},
+            "name": {"type": "string"},
+            "value": {"type": ["string", "null"]}
+          }
+        }
+      }
+    },
+    "Safe_Access_Property": {
+      "type": "Compose",
+      "inputs": "@coalesce(body('Parse_JSON_FIXED')?['value'], 'default')",
+      "runAfter": {
+        "Parse_JSON_FIXED": ["Succeeded"]
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Add Parse JSON action with proper schema
+2. Use `?['property']` for safe navigation (optional chaining)
+3. Use `coalesce()` for default values with null properties
+4. Test with sample payload first
+
+**Schema generation tip**:
+- Copy sample JSON response
+- Use "Generate from sample" in Parse JSON action
+- Add `"null"` to type array for optional fields: `{"type": ["string", "null"]}`
+
+---
+
+### Timeout Errors
+
+**Pattern Recognition**:
+- Error: "timeout", "timed out"
+- Context: Large files, long operations, Do until loops
+
+**Immediate Fix - Do Until**:
+
+```json
+{
+  "actions": {
+    "Do_until_FIXED": {
+      "type": "Until",
+      "expression": "@equals(variables('Complete'), true)",
+      "limit": {
+        "count": 60,
+        "timeout": "PT1H"
+      },
+      "actions": {
+        "Your_Action": {
+          "type": "Compose",
+          "inputs": "@variables('Data')"
+        },
+        "Check_Complete": {
+          "type": "SetVariable",
+          "inputs": {
+            "name": "Complete",
+            "value": "@greater(length(variables('Data')), 0)"
+          },
+          "runAfter": {
+            "Your_Action": ["Succeeded"]
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Always set `limit.count` and `limit.timeout` in Do until
+2. Recommended: count=60, timeout="PT1H" (1 hour)
+3. Add exit condition that WILL eventually be true
+4. Test with smaller iterations first
+
+**Immediate Fix - Large Files**:
+
+```json
+{
+  "actions": {
+    "Check_File_Size_FIXED": {
+      "type": "If",
+      "expression": {
+        "and": [{
+          "lessOrEquals": [
+            "@triggerBody()?['Size']",
+            50000000
+          ]
+        }]
+      },
+      "actions": {
+        "Process_Normal_File": {
+          "type": "ApiConnection",
+          "inputs": { /* your file action */ }
+        }
+      },
+      "else": {
+        "actions": {
+          "Log_Large_File": {
+            "type": "Compose",
+            "inputs": "File over 50MB - skipping"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Add file size check before processing
+2. OneDrive: 50MB limit (50000000 bytes)
+3. SharePoint attachments: 90MB limit (94371840 bytes)
+4. Alternative: Use different API for large files
+
+---
+
+### Not Found Errors (404)
+
+**Pattern Recognition**:
+- Status: 404
+- Keywords: "not found", "does not exist"
+
+**Immediate Fix**:
+
+```json
+{
+  "actions": {
+    "Try_Get_Item": {
+      "type": "Scope",
+      "actions": {
+        "Get_Item": {
+          "type": "ApiConnection",
+          "inputs": { /* your get action */ }
+        }
+      }
+    },
+    "Handle_Not_Found": {
+      "type": "If",
+      "expression": {
+        "and": [{
+          "equals": [
+            "@result('Try_Get_Item')[0]['status']",
+            "Failed"
+          ]
+        }]
+      },
+      "runAfter": {
+        "Try_Get_Item": ["Failed", "Succeeded"]
+      },
+      "actions": {
+        "Create_If_Missing": {
+          "type": "ApiConnection",
+          "inputs": { /* your create action */ }
+        }
+      },
+      "else": {
+        "actions": {
+          "Use_Existing": {
+            "type": "Compose",
+            "inputs": "@body('Get_Item')"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Instructions**:
+1. Wrap Get action in Scope
+2. Check result status with `result()` function
+3. Create item if not found (or handle alternative)
+4. Use dynamic IDs from previous actions (don't hardcode)
+
+---
+
+### Expression Errors
+
+**Pattern Recognition**:
+- Error: "Unable to process template language expressions"
+- Keywords: "property doesn't exist", "invalid expression"
+
+**Common Quick Fixes**:
+
+**Missing Property**:
+```javascript
+// BAD
+@body('Get_Item')['MissingProperty']
+
+// GOOD
+@body('Get_Item')?['MissingProperty']
+
+// BETTER (with default)
+@coalesce(body('Get_Item')?['MissingProperty'], 'default_value')
+```
+
+**Type Mismatch**:
+```javascript
+// BAD - concatenating string and number
+@concat('Value: ', variables('NumberVariable'))
+
+// GOOD
+@concat('Value: ', string(variables('NumberVariable')))
+```
+
+**Array Access**:
+```javascript
+// BAD - array might be empty
+@first(body('Get_Items')?['value'])
+
+// GOOD
+@if(greater(length(body('Get_Items')?['value']), 0), first(body('Get_Items')?['value']), null)
+```
+
+**Null Checks**:
+```javascript
+// BAD
+@variables('NullableVar')
+
+// GOOD
+@if(empty(variables('NullableVar')), 'default', variables('NullableVar'))
+```
+
+**Function Parenthesis Placement** (NEW!):
+```javascript
+// BAD - format parameter outside formatDateTime()
+toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
+//                                                     ↑
+//                              This closes formatDateTime BEFORE format string!
+
+// ERROR MESSAGE:
+// "The template language function 'toLower' expects one parameter:
+//  the string to convert to lower casing. The function was invoked with '2' parameters."
+
+// GOOD - format parameter INSIDE formatDateTime()
+toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
+//                                                      ↑
+//                          Format string is now INSIDE formatDateTime()
+```
+
+**Copy-Paste Fix for Filter Query**:
+```javascript
+// Original (broken):
+@and(
+  contains(toLower(item()), 'cnesst'),
+  contains(
+    toLower(item()),
+    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
+  )
+
+// Fixed expression (ready to copy-paste into Filter Query action):
+@and(
+  contains(toLower(item()), 'cnesst'),
+  contains(
+    toLower(item()),
+    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
+  )
+)
+```
+
+---
+
+## Quick Fix Decision Tree
+
+```
+Error Code/Type
+│
+├── Data Structure Mismatch (item() vs item()?['Prop']) → ❌ Use automation-debugger (NOT quick fix)
+│
+├── 401/403 → Re-authenticate connection + Add error handling
+│
+├── 429 → Set concurrency=1 + Add delays
+│
+├── 404 → Add existence check + Handle not found case
+│
+├── Timeout → Add limits to Do until OR check file sizes
+│
+├── Parse JSON → Add schema + Use safe navigation (?[])
+│
+└── Expression Errors
+    ├── "Function expects N parameters but was invoked with M" → Check parenthesis placement
+    ├── Missing/null properties → Add ?[] + coalesce()
+    ├── Type mismatch → Add string(), int() conversions
+    └── Array access → Add length checks + first()/last()
+```
+
+## When Quick Fix Isn't Enough
+
+Escalate to automation-debugger skill if:
+- Quick fix doesn't resolve the error
+- Error doesn't match common patterns
+- Multiple interrelated errors
+- Complex flow logic involved
+- Need deep documentation research
+- Unclear root cause
+
+## Output Format
+
+Quick fixes provide:
+1. **Pattern identification** (which common error)
+2. **Immediate fix** (JSON snippet for actions/nodes)
+3. **Copy-paste ready expressions** (for Filter Query, Condition, Variable, etc.) - ALWAYS include the complete @{...} expression ready to copy directly into Power Automate
+4. **Instructions** (how to apply)
+5. **Validation** (how to test)
+
+**IMPORTANT**: For expression errors (Filter Query, Condition, Variable, Compose, etc.), ALWAYS provide:
+- ❌ **Original (broken)**: The full broken expression
+- ✅ **Fixed expression**: The complete corrected expression ready to copy-paste
+
+**Example output format**:
+```
+Quick Fix: Function Parenthesis Placement Error
+
+Pattern: formatDateTime() format parameter placed outside function call
+
+Original (broken):
+@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date']),'yyyy-MM')))
+
+Fixed expression (copy-paste ready):
+@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))))
+
+What changed: Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses
+```
+
+No need for full debug report structure - focus on speed and copy-paste ready fixes.
+
+## Best Practices
+
+1. **Test first**: Apply quick fix to copy of flow
+2. **Verify limits**: Confirm connector-specific constraints
+3. **Monitor**: Check flow run history after fix
+4. **Escalate if needed**: Use automation-debugger for persistent issues
+
+## Common Connector Limits (Quick Reference)
+
+| Connector | API Limit | Recommended Delay |
+|-----------|-----------|-------------------|
+| SharePoint | 600/60s | 1 second |
+| OneDrive | 100/60s | 3 seconds |
+| HTTP | 600/60s | 1 second |
+| Apply to each | 50 concurrent | Set to 1 for APIs |
+
+## Examples
+
+**User**: "I'm getting throttled in SharePoint, need quick fix"
+
+**Output**:
+```
+Quick Fix: SharePoint Throttling (429)
+
+Reduce concurrency and add delays:
+
+[JSON snippet with concurrency + delay]
+
+Apply these changes:
+1. Set concurrency to 1
+2. Add 1-second delay
+3. Save and test
+
+This limits you to 60 API calls/minute (well under 600/minute limit).
+```
+
+**User**: "Parse JSON failing with 'property doesn't exist'"
+
+**Output**:
+```
+Quick Fix: Parse JSON Property Access
+
+Use safe navigation (?[]) and defaults:
+
+[JSON snippet with coalesce()]
+
+Changes needed:
+1. Replace ['property'] with ?['property']
+2. Add coalesce() for defaults
+3. Test with sample data
+
+This handles null/missing properties gracefully.
+```
+
+**User**: "Getting error 'toLower expects one parameter but was invoked with 2 parameters' in my Filter Query"
+
+**Output**:
+```
+Quick Fix: Function Parenthesis Placement Error
+
+Pattern: formatDateTime() format parameter placed outside function call
+
+Original (broken):
+@and(
+  contains(toLower(item()), 'cnesst'),
+  contains(
+    toLower(item()),
+    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
+  )
+
+Fixed expression (copy-paste ready):
+@and(
+  contains(toLower(item()), 'cnesst'),
+  contains(
+    toLower(item()),
+    toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
+  )
+)
+
+What changed:
+1. Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses (before the closing parenthesis)
+2. The format parameter is now the second parameter of formatDateTime(), not a second parameter to toLower()
+
+How to apply:
+1. Open your Filter Query action in Power Automate
+2. Delete the current expression
+3. Paste the fixed expression above
+4. Save and test with your data
+```
+
+---
+
+## Integration with Other Skills
+
+- **Quick fix succeeds** → Done!
+- **Quick fix fails** → Automatically suggest automation-debugger
+- **Unknown error** → Immediately defer to automation-debugger
+
+This skill optimizes for speed on common patterns while maintaining quality through specialized skill delegation when needed.
+
+---
+
+**Version**: 1.2
+**Last Updated**: 2025-10-31
+
+## Changelog
+
+### Version 1.2 (2025-10-31)
+
+**Major Enhancements**:
+- ✅ Added **Function Parenthesis Placement Error** pattern to Expression Errors
+- ✅ Enhanced **Output Format** to emphasize copy-paste ready expressions for all expression types
+- ✅ Updated **Activation Triggers** to include expression error patterns
+- ✅ Expanded **Decision Tree** with detailed expression error breakdown
+- ✅ Added **complete example** showing function parenthesis error fix
+
+**Key Additions**:
+- Function parameter placement detection (e.g., `toLower(formatDateTime(...), 'format')` → error)
+- Copy-paste ready expression format with ❌ broken / ✅ fixed sections
+- Direct support for Filter Query, Condition, Variable, Compose expression fixes
+- Clear before/after comparison showing exactly what changed
+
+**New Triggers**:
+- "Function expects one parameter but was invoked with 2"
+- "Unable to process template language expressions"
+- "Fix this expression/filter/query/condition"
+- User provides code snippet and asks for "quick fix"
+
+**Output Philosophy**:
+- Always provide complete, ready-to-paste expressions
+- Show original (broken) and fixed versions side-by-side
+- Explain exactly what changed and why
+- Include step-by-step application instructions
+
+### Version 1.1 (2025-10-31)
+
+**Minor Improvements**:
+- ✅ Added **Data Structure Check section** - Quick validation before applying fixes
+- ✅ Added **Data Structure Mismatch pattern** - Recognizes when NOT to quick fix
+- ✅ Updated **Decision Tree** - Now includes structural bug detection
+- ✅ Clarified escalation to **automation-debugger** for structural issues
+
+**Key Additions**:
+- Quick data type check: `item()` vs `item()?['Property']` indicator
+- Clear guidance on when quick fix is inappropriate
+- Structural bugs (string vs object mismatch) → Use automation-debugger
+
+**Philosophy**:
+- Quick fixes are for **known, simple patterns**
+- Data structure bugs require **deep analysis** → Not quick fix territory
+- Fast triage: Recognize when to escalate immediately