@nockdev/awf 6.2.0

package/.agent/templates/chains/debug/step3-analyze.md

@@ -0,0 +1,86 @@
+# Debug Chain — Step 3: Analyze
+
+> Prompt chaining step for debugging process
+
+---
+
+## Context
+
+With the issue isolated, analyze to find root cause.
+
+## Input
+
+```yaml
+{ { isolation } }
+```
+
+## Task
+
+### 1. Form Hypotheses
+
+Based on isolated area, form max 3 hypotheses:
+
+| #   | Hypothesis | Likelihood | Test          |
+| --- | ---------- | ---------- | ------------- |
+| 1   | [Theory 1] | High       | [How to test] |
+| 2   | [Theory 2] | Medium     | [How to test] |
+| 3   | [Theory 3] | Low        | [How to test] |
+
+### 2. Test Each Hypothesis
+
+For each hypothesis:
+
+- Design a test
+- Execute the test
+- Record the result
+- Confirm or eliminate
+
+### 3. Identify Root Cause
+
+- Which hypothesis was correct?
+- Why did this happen?
+- What's the exact code path?
+
+## Output Format
+
+```yaml
+root_cause:
+  hypotheses:
+    - id: 1
+      theory: "[Description of theory]"
+      likelihood: "high"
+      test: "[How you tested it]"
+      result: "confirmed|eliminated"
+      evidence: "[What proved/disproved it]"
+    - id: 2
+      theory: "[Description of theory]"
+      likelihood: "medium"
+      test: "[How you tested it]"
+      result: "confirmed|eliminated"
+      evidence: "[What proved/disproved it]"
+    - id: 3
+      theory: "[Description of theory]"
+      likelihood: "low"
+      test: "[How you tested it]"
+      result: "confirmed|eliminated"
+      evidence: "[What proved/disproved it]"
+
+  confirmed_cause:
+    location: "file:line"
+    code: |
+      // The problematic code
+    explanation: "[Why this causes the issue]"
+    root_reason: "[The fundamental reason - not just symptoms]"
+
+  contributing_factors:
+    - "[Factor 1 that contributed]"
+    - "[Factor 2 that contributed]"
+
+  why_not_caught:
+    - "[Why tests didn't catch this]"
+    - "[What was missing]"
+```
+
+---
+
+_Chain Step 3 of 5 • Input: isolation • Output: root_cause_

package/.agent/templates/chains/debug/step4-fix.md

@@ -0,0 +1,85 @@
+# Debug Chain — Step 4: Fix
+
+> Prompt chaining step for debugging process
+
+---
+
+## Context
+
+With root cause identified, implement the fix.
+
+## Input
+
+```yaml
+{ { root_cause } }
+```
+
+## Task
+
+### 1. Design the Fix
+
+Consider:
+
+- Minimal change to fix the issue
+- Side effects
+- Backward compatibility
+- Related areas that might need update
+
+### 2. Implement the Fix
+
+Apply the change:
+
+- Make the minimal fix
+- Don't change unrelated code
+- Keep the fix focused
+
+### 3. Add Regression Test
+
+Write a test that:
+
+- Would have caught this bug
+- Covers the edge case
+- Prevents future regression
+
+## Output Format
+
+```yaml
+fix:
+  approach:
+    strategy: "[Description of fix approach]"
+    alternatives_considered:
+      - option: "[Alternative 1]"
+        rejected_because: "[Why not chosen]"
+      - option: "[Alternative 2]"
+        rejected_because: "[Why not chosen]"
+
+  changes:
+    - file: "path/to/file"
+      type: "modify|add|delete"
+      before: |
+        // Old code
+      after: |
+        // New code
+      explanation: "[Why this change fixes it]"
+
+  side_effects:
+    - area: "[Affected area]"
+      impact: "[What might be affected]"
+      mitigation: "[How it's handled]"
+
+  regression_test:
+    file: "path/to/test_file"
+    test_name: "test_specific_case_that_was_broken"
+    code: |
+      // Test code that would have caught this
+    covers: "[What this test covers]"
+
+  verification_steps:
+    1: "[How to verify the fix works]"
+    2: "[Another verification step]"
+    3: "[Final verification]"
+```
+
+---
+
+_Chain Step 4 of 5 • Input: root_cause • Output: fix_

package/.agent/templates/chains/debug/step5-verify.md

@@ -0,0 +1,122 @@
+# Debug Chain — Step 5: Verify
+
+> Final step: Verify the fix and document
+
+---
+
+## Context
+
+Fix is applied, now verify it works and document.
+
+## Input
+
+```yaml
+{ { fix } }
+```
+
+## Task
+
+### 1. Verify Fix Works
+
+- [ ] Original error no longer occurs
+- [ ] Reproduction steps now succeed
+- [ ] New test passes
+- [ ] Existing tests still pass
+
+### 2. Check for Regressions
+
+- [ ] Related functionality works
+- [ ] No new errors in logs
+- [ ] Performance not degraded
+
+### 3. Document for Future
+
+- What was learned?
+- How can similar issues be prevented?
+- What patterns should be added?
+
+## Output Format
+
+```markdown
+## 🐛 Bug Fix Report
+
+### Summary
+
+**Issue:** [One-line description]
+**Root Cause:** [One-line root cause]
+**Fix:** [One-line fix description]
+
+---
+
+### Investigation Trail
+
+| Step      | Finding             |
+| --------- | ------------------- |
+| Reproduce | [How reproduced]    |
+| Isolate   | [Where isolated to] |
+| Analyze   | [Root cause found]  |
+| Fix       | [Fix applied]       |
+
+### Root Cause Analysis
+
+**Location:** `file:line`
+
+**Code Path:**
+```
+
+function1() → function2() → [problem]
+
+````
+
+**Why it Happened:**
+[Detailed explanation]
+
+---
+
+### Fix Applied
+
+**Files Changed:**
+- `file1.go` — [Description]
+- `file2.go` — [Description]
+
+**Key Change:**
+```diff
+- old code
++ new code
+````
+
+---
+
+### Verification
+
+| Check                | Status |
+| -------------------- | ------ |
+| Original error fixed | ✅     |
+| New test added       | ✅     |
+| Existing tests pass  | ✅     |
+| No regressions       | ✅     |
+
+---
+
+### Prevention
+
+**Test Added:** `test_file:test_name`
+
+**Recommendations:**
+
+1. [Recommendation to prevent similar issues]
+2. [Another recommendation]
+
+**Pattern Learned:**
+[If there's a general pattern to add to patterns/bugs_fixed.json]
+
+---
+
+_Fixed by: AI Debug • {{DATE}}_
+
+```
+
+---
+
+_Chain Step 5 of 5 • Input: fix • Output: Final Report_
+```

package/.agent/templates/chains/implement/step1-plan.md

@@ -0,0 +1,88 @@
+# Implement Chain — Step 1: Plan
+
+> Prompt chaining step for implementation process
+
+---
+
+## Context
+
+You are implementing a feature or change. First, create a plan.
+
+## Input
+
+```
+{{TASK_DESCRIPTION}}
+{{REQUIREMENTS}}
+```
+
+## Task
+
+### 1. Understand Requirements
+
+- What needs to be built?
+- What are the acceptance criteria?
+- Any constraints or limitations?
+
+### 2. Identify Scope
+
+- Which files need changes?
+- New files to create?
+- Dependencies needed?
+
+### 3. Break Down Tasks
+
+Create a step-by-step implementation plan.
+
+## Output Format
+
+```yaml
+plan:
+  understanding:
+    goal: "[What we're building]"
+    acceptance_criteria:
+      - "[Criterion 1]"
+      - "[Criterion 2]"
+    constraints:
+      - "[Constraint 1]"
+      - "[Constraint 2]"
+
+  scope:
+    files_to_create:
+      - path: "path/to/new/file"
+        purpose: "[Why this file]"
+    files_to_modify:
+      - path: "path/to/existing/file"
+        changes: "[What changes]"
+    dependencies:
+      - name: "[Package name]"
+        version: "[Version]"
+        reason: "[Why needed]"
+
+  tasks:
+    - id: 1
+      title: "[Task title]"
+      description: "[What to do]"
+      files: ["file1", "file2"]
+      estimated_lines: 50
+      dependencies: []
+    - id: 2
+      title: "[Task title]"
+      description: "[What to do]"
+      files: ["file3"]
+      estimated_lines: 30
+      dependencies: [1]
+    # ...more tasks
+
+  total_estimate:
+    files: X
+    lines: Y
+    complexity: "[low|medium|high]"
+
+  risks:
+    - risk: "[Potential risk]"
+      mitigation: "[How to mitigate]"
+```
+
+---
+
+_Chain Step 1 of 4 • Output: plan_

package/.agent/templates/chains/implement/step2-code.md

@@ -0,0 +1,87 @@
+# Implement Chain — Step 2: Implement
+
+> Prompt chaining step for implementation process
+
+---
+
+## Context
+
+Based on the plan, implement the code.
+
+## Input
+
+```yaml
+{ { plan } }
+```
+
+## Task
+
+For each task in the plan:
+
+### 1. Write Quality Code
+
+Follow best practices:
+
+- Clear naming
+- Proper error handling
+- Type safety
+- Appropriate comments
+
+### 2. Apply Design Patterns
+
+Use appropriate patterns:
+
+- SOLID principles
+- DRY (Don't Repeat Yourself)
+- KISS (Keep It Simple)
+
+### 3. Handle Edge Cases
+
+Consider:
+
+- Invalid inputs
+- Error conditions
+- Boundary cases
+
+## Output Format
+
+```yaml
+code:
+  completed_tasks:
+    - task_id: 1
+      status: "complete"
+      files_created:
+        - path: "path/to/new/file"
+          language: "typescript"
+          lines: 45
+          key_exports: ["function1", "function2"]
+      files_modified:
+        - path: "path/to/modified/file"
+          changes_summary: "[What was changed]"
+          lines_added: 10
+          lines_removed: 5
+    # ...more tasks
+
+  code_samples:
+    - file: "path/to/file"
+      highlight: "Key implementation"
+      code: |
+        // Important code snippet
+
+  decisions:
+    - decision: "[What was decided]"
+      reason: "[Why this approach]"
+      alternatives: "[What was considered]"
+
+  dependencies_added:
+    - name: "package-name"
+      version: "1.0.0"
+      command: "npm install package-name"
+
+  notes:
+    - "[Any important notes for reviewers]"
+```
+
+---
+
+_Chain Step 2 of 4 • Input: plan • Output: code_

package/.agent/templates/chains/implement/step3-test.md

@@ -0,0 +1,87 @@
+# Implement Chain — Step 3: Test
+
+> Prompt chaining step for implementation process
+
+---
+
+## Context
+
+Code is implemented, now add tests.
+
+## Input
+
+```yaml
+{ { code } }
+```
+
+## Task
+
+### 1. Write Unit Tests
+
+For each new function/method:
+
+- Test happy path
+- Test edge cases
+- Test error conditions
+
+### 2. Write Integration Tests
+
+If applicable:
+
+- Test component interactions
+- Test data flow
+
+### 3. Verify All Tests Pass
+
+- Run the test suite
+- Ensure no regressions
+
+## Output Format
+
+```yaml
+tests:
+  unit_tests:
+    - file: "path/to/test/file"
+      tests:
+        - name: "test_function_with_valid_input"
+          type: "happy_path"
+          covers: "function_name"
+          code: |
+            test('should return correct result', () => {
+              // Arrange, Act, Assert
+            });
+        - name: "test_function_with_invalid_input"
+          type: "error_handling"
+          covers: "function_name"
+          code: |
+            test('should throw error', () => {
+              // ...
+            });
+    # ...more test files
+
+  integration_tests:
+    - file: "path/to/integration/test"
+      tests:
+        - name: "test_full_flow"
+          covers: "[What flow is covered]"
+
+  test_results:
+    total: 10
+    passed: 10
+    failed: 0
+    duration: "1.5s"
+
+  coverage:
+    lines: "92%"
+    branches: "85%"
+    functions: "95%"
+
+  coverage_gaps:
+    - file: "path/to/file"
+      uncovered: "lines 45-48"
+      reason: "[Why not covered or todo]"
+```
+
+---
+
+_Chain Step 3 of 4 • Input: code • Output: tests_

package/.agent/templates/chains/implement/step4-doc.md

@@ -0,0 +1,118 @@
+# Implement Chain — Step 4: Review
+
+> Final step: Self-review and summary
+
+---
+
+## Context
+
+Implementation and tests complete. Self-review before submission.
+
+## Input
+
+```yaml
+{{code}}
+{{tests}}
+```
+
+## Task
+
+### 1. Self-Review Checklist
+
+- [ ] Code follows project conventions
+- [ ] All acceptance criteria met
+- [ ] Error handling complete
+- [ ] Tests cover key paths
+- [ ] No security issues
+- [ ] Documentation added
+
+### 2. Generate Summary
+
+Create implementation summary for user/reviewer.
+
+## Output Format
+
+````markdown
+## 💻 Implementation Complete
+
+### Summary
+
+**Feature:** [Feature name]
+**Status:** ✅ Complete
+
+---
+
+### Files Changed
+
+| File            | Action   | Lines  | Purpose    |
+| --------------- | -------- | ------ | ---------- |
+| `path/to/file`  | Created  | +45    | [Purpose]  |
+| `path/to/file2` | Modified | +12/-5 | [Purpose]  |
+| `path/to/test`  | Created  | +30    | Unit tests |
+
+**Total:** +X lines, -Y lines, Z files
+
+---
+
+### Key Decisions
+
+1. **[Decision 1]**
+   - Chose: [What was chosen]
+   - Reason: [Why this approach]
+
+2. **[Decision 2]**
+   - Chose: [What was chosen]
+   - Reason: [Why this approach]
+
+---
+
+### Verification
+
+| Check    | Status          |
+| -------- | --------------- |
+| Build    | ✅ Passes       |
+| Lint     | ✅ Passes       |
+| Tests    | ✅ 10/10 passed |
+| Coverage | ✅ 92%          |
+
+---
+
+### Acceptance Criteria
+
+- [x] [Criterion 1]
+- [x] [Criterion 2]
+- [x] [Criterion 3]
+
+---
+
+### Usage Example
+
+```typescript
+// How to use the new feature
+import { newFunction } from "./path";
+
+const result = await newFunction({
+  option: "value",
+});
+```
+````
+
+---
+
+### Next Steps
+
+1. [ ] Code review
+2. [ ] Merge to main
+3. [ ] Deploy to staging
+4. [ ] Monitor for issues
+
+---
+
+_Implemented by: AI Developer • {{DATE}}_
+
+```
+
+---
+
+_Chain Step 4 of 4 • Input: code, tests • Output: Final Summary_
+```