docs: add test-case-enhancement.md

Author: wislertt

.amazonq/rules/test-case-enhancement.md

@@ -0,0 +1,124 @@
+# Test Case Enhancement Rules
+
+## Assistant Workflow for Adding Comprehensive Test Cases
+
+When user requests to enhance test cases for a problem, the assistant will:
+
+### 1. Problem Resolution (Priority Order)
+
+- **FIRST**: Try to resolve from context - check active file path or user-provided problem name
+- **SECOND**: If context resolution fails, THEN run `poetry run python .templates/check_test_cases.py --threshold=10 --max=1` to auto-detect 1 problem with <10 test cases
+- **LAST**: If both above fail, ask user to explicitly specify problem name
+
+### 2. Test Case Generation
+
+- Read `leetcode/{problem_name}/README.md` for problem understanding
+- Analyze existing test cases in `leetcode/{problem_name}/tests.py`
+- Generate comprehensive test cases covering:
+    - **Edge cases**: Empty inputs, single elements, boundary values
+    - **Corner cases**: Maximum/minimum constraints, special patterns
+    - **Normal cases**: Typical scenarios with varied complexity
+    - **Error cases**: Invalid inputs (if applicable)
+
+### 3. Initial Validation
+
+- Run `make p-test PROBLEM={problem_name}` to verify current implementation
+- **If errors found**:
+    - DO NOT update implementation automatically
+    - Only update test cases if they're incorrect
+    - If implementation seems wrong, ASK USER first before modifying
+
+### 4. JSON Template Update
+
+- Update corresponding `.templates/leetcode/json/{problem_name}.json`
+- Add new test cases to `test_cases` field in proper format
+- Maintain existing test structure and naming conventions
+
+### 5. Backup and Regeneration Process
+
+- **Backup**: Move `leetcode/{problem_name}/` to `.cache/leetcode/{problem_name}/`
+- **Regenerate**: Run `make p-gen PROBLEM={problem_name} FORCE=1`
+- **Lint check**: Run `make p-lint PROBLEM={problem_name}`
+- **Iterate**: If lint fails, update JSON and regenerate until passes
+
+### 6. Solution Preservation
+
+- Copy `solution.py` from backup to newly generated structure
+- Run `make p-test PROBLEM={problem_name}` to verify tests pass
+- **If tests fail**: Go back to step 4, update JSON, and iterate until passes
+
+### 7. Cleanup and Restore
+
+- Remove newly generated files
+- Restore original structure from backup
+- Verify final state with `make p-test PROBLEM={problem_name}`
+
+## Test Case Quality Standards
+
+### Coverage Requirements
+
+- **Minimum 10 test cases** per problem
+- **Edge cases**: 20-30% of total test cases
+- **Normal cases**: 50-60% of total test cases
+- **Corner cases**: 20-30% of total test cases
+
+### Test Case Categories
+
+#### Edge Cases
+
+- Empty inputs: `[]`, `""`, `None`
+- Single element: `[1]`, `"a"`
+- Boundary values: `[0]`, `[1]`, `[-1]`
+- Maximum/minimum constraints from problem description
+
+#### Corner Cases
+
+- Duplicate elements: `[1,1,1]`
+- Sorted/reverse sorted arrays: `[1,2,3]`, `[3,2,1]`
+- All same elements: `[5,5,5,5]`
+- Alternating patterns: `[1,0,1,0]`
+
+#### Normal Cases
+
+- Mixed positive/negative numbers
+- Various array sizes within constraints
+- Different data patterns and structures
+- Representative problem scenarios
+
+### JSON Format Requirements
+
+- Use single quotes for Python strings in test cases
+- Follow existing parametrize format
+- Maintain type hints in parametrize_typed
+- Ensure test_cases string is valid Python list syntax
+
+## Commands Reference
+
+```bash
+# Find problems needing more test cases
+poetry run python .templates/check_test_cases.py --threshold=10 --max=1
+
+# Test specific problem
+make p-test PROBLEM={problem_name}
+
+# Generate from JSON template
+make p-gen PROBLEM={problem_name} FORCE=1
+
+# Lint specific problem
+make p-lint PROBLEM={problem_name}
+```
+
+## Error Handling
+
+- **Implementation errors**: Ask user before modifying solution code
+- **Test failures**: Update JSON template and regenerate
+- **Lint failures**: Fix JSON format and iterate
+- **Backup failures**: Ensure `.cache/leetcode/` directory exists
+
+## Success Criteria
+
+- All tests pass with enhanced test cases
+- Minimum 10 comprehensive test cases per problem
+- Original solution code preserved and working
+- JSON template updated for future regeneration
+- Clean final state with no temporary files

.templates/check_test_cases.py

@@ -2,6 +2,9 @@
 
 import json
 from pathlib import Path
+from typing import Optional
+import typer
+
 
 def count_test_cases(json_data):
     """Count total test cases across all test methods."""
@@ -15,31 +18,74 @@ def count_test_cases(json_data):
     for method in test_methods:
         test_cases = method.get("test_cases", "")
         if test_cases.strip():
-            # Count tuples/lists in test_cases string
-            total += max(test_cases.count("("), test_cases.count("["))
+            # Parse the test_cases string to count actual test cases
+            try:
+                # Remove outer brackets and split by top-level commas
+                cases_str = test_cases.strip()
+                if cases_str.startswith("[") and cases_str.endswith("]"):
+                    cases_str = cases_str[1:-1]  # Remove outer brackets
+
+                # Count test cases by counting commas at parenthesis depth 0
+                depth = 0
+                case_count = 1 if cases_str.strip() else 0
+
+                for char in cases_str:
+                    if char in "([{":
+                        depth += 1
+                    elif char in ")]}":
+                        depth -= 1
+                    elif char == "," and depth == 0:
+                        case_count += 1
+
+                total += case_count
+            except Exception:
+                # Fallback to old method if parsing fails
+                total += test_cases.count("(") - test_cases.count("([") + test_cases.count("[(")
     return total
 
-def main():
+
+def main(
+    threshold: int = typer.Option(
+        10, "--threshold", "-t", help="Show files with test cases <= threshold"
+    ),
+    max_results: str = typer.Option(
+        1, "--max", "-m", help="Maximum number of results to show ('none' for no limit)"
+    ),
+):
+    """Check test case counts in LeetCode JSON templates."""
     json_dir = Path(".templates/leetcode/json")
-    files_with_few_tests = []
+    all_files = []
 
     for json_file in json_dir.glob("*.json"):
         try:
             with open(json_file) as f:
                 data = json.load(f)
 
             test_count = count_test_cases(data)
-            if test_count <= 10:
-                files_with_few_tests.append((json_file.name, test_count))
+            all_files.append((json_file.name, test_count))
         except Exception as e:
-            print(f"Error reading {json_file.name}: {e}")
+            typer.echo(f"Error reading {json_file.name}: {e}", err=True)
 
     # Sort by test count
-    files_with_few_tests.sort(key=lambda x: x[1])
+    all_files.sort(key=lambda x: x[1])
+
+    # Filter by threshold
+    filtered_files = [f for f in all_files if f[1] <= threshold]
+
+    # Apply max results limit
+    if max_results.lower() not in ["none", "null", "-1"]:
+        try:
+            max_count = int(max_results)
+            if max_count > 0:
+                filtered_files = filtered_files[:max_count]
+        except ValueError:
+            typer.echo(f"Invalid max_results value: {max_results}", err=True)
+            raise typer.Exit(1)
+
+    typer.echo(f"Files with ≤{threshold} test cases ({len(filtered_files)} total):")
+    for filename, count in filtered_files:
+        typer.echo(f"{filename}: {count} test cases")
 
-    print(f"Files with ≤10 test cases ({len(files_with_few_tests)} total):")
-    for filename, count in files_with_few_tests:
-        print(f"{filename}: {count} test cases")
 
 if __name__ == "__main__":
-    main()
+    typer.run(main)