thanh-kit 2.5.0 → 2.5.2

package/templates/skills/context-engineering/scripts/tests/test_edge_cases.py

@@ -0,0 +1,246 @@
+"""Tests for context-engineering edge case handling.
+
+Tests the error handling improvements in compression_evaluator.py and context_analyzer.py:
+- File not found
+- Permission denied
+- Invalid JSON
+- File too large
+- UTF-8 encoding
+"""
+
+import json
+import os
+import stat
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIR = Path(__file__).parent.parent
+PYTHON = sys.executable
+
+
+class TestCompressionEvaluatorEdgeCases:
+    """Test edge cases in compression_evaluator.py"""
+
+    @pytest.fixture
+    def valid_json_file(self, tmp_path):
+        """Create valid JSON file."""
+        f = tmp_path / "valid.json"
+        f.write_text('{"messages": [{"role": "user", "content": "hello"}]}', encoding='utf-8')
+        return str(f)
+
+    @pytest.fixture
+    def valid_text_file(self, tmp_path):
+        """Create valid text file."""
+        f = tmp_path / "compressed.txt"
+        f.write_text("Summary of conversation", encoding='utf-8')
+        return str(f)
+
+    def run_script(self, *args, timeout=30):
+        """Run compression_evaluator.py with args."""
+        cmd = [PYTHON, str(SCRIPTS_DIR / "compression_evaluator.py")] + list(args)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return result
+
+    def test_missing_file_exits_1(self, tmp_path):
+        """Test exit code 1 when file not found."""
+        result = self.run_script("evaluate", "/nonexistent/file.json", str(tmp_path / "c.txt"))
+        assert result.returncode == 1
+        assert "File not found" in result.stderr
+
+    def test_missing_file_error_message(self, tmp_path):
+        """Test error message format for missing file."""
+        missing = "/this/path/does/not/exist/file.json"
+        result = self.run_script("evaluate", missing, str(tmp_path / "c.txt"))
+        assert result.returncode == 1
+        assert missing in result.stderr or "not found" in result.stderr.lower()
+
+    def test_invalid_json_exits_1(self, tmp_path, valid_text_file):
+        """Test exit code 1 when JSON is invalid."""
+        bad_json = tmp_path / "bad.json"
+        bad_json.write_text("{invalid json content", encoding='utf-8')
+
+        result = self.run_script("evaluate", str(bad_json), valid_text_file)
+        assert result.returncode == 1
+        assert "Invalid JSON" in result.stderr or "JSON" in result.stderr
+
+    def test_valid_files_succeed(self, valid_json_file, valid_text_file):
+        """Test success with valid inputs."""
+        result = self.run_script("evaluate", valid_json_file, valid_text_file)
+        assert result.returncode == 0
+        output = json.loads(result.stdout)
+        assert "compression_ratio" in output
+        assert "quality_score" in output
+
+    def test_generate_probes_missing_file(self):
+        """Test generate-probes with missing file."""
+        result = self.run_script("generate-probes", "/nonexistent/context.json")
+        assert result.returncode == 1
+        assert "File not found" in result.stderr
+
+    def test_generate_probes_invalid_json(self, tmp_path):
+        """Test generate-probes with invalid JSON."""
+        bad = tmp_path / "bad.json"
+        bad.write_text("not valid json {{{", encoding='utf-8')
+
+        result = self.run_script("generate-probes", str(bad))
+        assert result.returncode == 1
+        assert "Invalid JSON" in result.stderr or "JSON" in result.stderr
+
+    def test_generate_probes_success(self, valid_json_file):
+        """Test generate-probes with valid file."""
+        result = self.run_script("generate-probes", valid_json_file)
+        assert result.returncode == 0
+        output = json.loads(result.stdout)
+        assert isinstance(output, list)
+
+    def test_utf8_content(self, tmp_path):
+        """Test UTF-8 encoding with special characters."""
+        utf8_file = tmp_path / "utf8.json"
+        content = {"messages": [{"role": "user", "content": "日本語テスト émojis 🎉"}]}
+        utf8_file.write_text(json.dumps(content), encoding='utf-8')
+
+        compressed = tmp_path / "compressed.txt"
+        compressed.write_text("Summary with 日本語 and émojis 🎉", encoding='utf-8')
+
+        result = self.run_script("evaluate", str(utf8_file), str(compressed))
+        assert result.returncode == 0
+
+    @pytest.mark.skipif(os.name == 'nt', reason="Permission test not reliable on Windows")
+    def test_permission_denied(self, tmp_path):
+        """Test permission denied error."""
+        protected = tmp_path / "protected.json"
+        protected.write_text('{"messages": []}', encoding='utf-8')
+        os.chmod(protected, 0o000)
+
+        try:
+            result = self.run_script("generate-probes", str(protected))
+            assert result.returncode == 1
+            assert "Permission denied" in result.stderr or "permission" in result.stderr.lower()
+        finally:
+            os.chmod(protected, stat.S_IRUSR | stat.S_IWUSR)
+
+
+class TestContextAnalyzerEdgeCases:
+    """Test edge cases in context_analyzer.py"""
+
+    @pytest.fixture
+    def valid_context_file(self, tmp_path):
+        """Create valid context file."""
+        f = tmp_path / "context.json"
+        content = {
+            "messages": [
+                {"role": "user", "content": "implement feature X"},
+                {"role": "assistant", "content": "I'll help with that"}
+            ]
+        }
+        f.write_text(json.dumps(content), encoding='utf-8')
+        return str(f)
+
+    def run_script(self, *args, timeout=30):
+        """Run context_analyzer.py with args."""
+        cmd = [PYTHON, str(SCRIPTS_DIR / "context_analyzer.py")] + list(args)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return result
+
+    def test_missing_file_exits_1(self):
+        """Test exit code 1 when file not found."""
+        result = self.run_script("analyze", "/nonexistent/context.json")
+        assert result.returncode == 1
+        assert "File not found" in result.stderr
+
+    def test_invalid_json_exits_1(self, tmp_path):
+        """Test exit code 1 when JSON is invalid."""
+        bad = tmp_path / "bad.json"
+        bad.write_text("not json", encoding='utf-8')
+
+        result = self.run_script("analyze", str(bad))
+        assert result.returncode == 1
+        assert "Invalid JSON" in result.stderr or "JSON" in result.stderr
+
+    def test_valid_file_succeeds(self, valid_context_file):
+        """Test success with valid input."""
+        result = self.run_script("analyze", valid_context_file)
+        assert result.returncode == 0
+        output = json.loads(result.stdout)
+        assert "health_status" in output or "health_score" in output
+
+    def test_utf8_content(self, tmp_path):
+        """Test UTF-8 encoding with international characters."""
+        utf8_file = tmp_path / "utf8.json"
+        content = {
+            "messages": [
+                {"role": "user", "content": "日本語で説明してください"},
+                {"role": "assistant", "content": "はい、説明します。émojis: 🎉🚀"}
+            ]
+        }
+        utf8_file.write_text(json.dumps(content, ensure_ascii=False), encoding='utf-8')
+
+        result = self.run_script("analyze", str(utf8_file))
+        assert result.returncode == 0
+
+    def test_empty_messages_array(self, tmp_path):
+        """Test handling of empty messages array."""
+        f = tmp_path / "empty.json"
+        f.write_text('{"messages": []}', encoding='utf-8')
+
+        result = self.run_script("analyze", str(f))
+        assert result.returncode == 0
+
+    def test_direct_messages_list(self, tmp_path):
+        """Test handling of direct messages list (no wrapper)."""
+        f = tmp_path / "direct.json"
+        content = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"}
+        ]
+        f.write_text(json.dumps(content), encoding='utf-8')
+
+        result = self.run_script("analyze", str(f))
+        assert result.returncode == 0
+
+    @pytest.mark.skipif(os.name == 'nt', reason="Permission test not reliable on Windows")
+    def test_permission_denied(self, tmp_path):
+        """Test permission denied error."""
+        protected = tmp_path / "protected.json"
+        protected.write_text('{"messages": []}', encoding='utf-8')
+        os.chmod(protected, 0o000)
+
+        try:
+            result = self.run_script("analyze", str(protected))
+            assert result.returncode == 1
+            assert "Permission denied" in result.stderr or "permission" in result.stderr.lower()
+        finally:
+            os.chmod(protected, stat.S_IRUSR | stat.S_IWUSR)
+
+    def test_with_keywords_filter(self, valid_context_file):
+        """Test analyze with keywords filter."""
+        result = self.run_script("analyze", valid_context_file, "--keywords", "feature,implement")
+        assert result.returncode == 0
+
+    def test_with_limit(self, valid_context_file):
+        """Test analyze with limit parameter."""
+        result = self.run_script("analyze", valid_context_file, "--limit", "10")
+        assert result.returncode == 0
+
+
+class TestFileSizeValidation:
+    """Test file size validation (100MB limit)."""
+
+    def test_large_file_warning_in_code(self):
+        """Verify MAX_FILE_SIZE_MB constant exists in scripts."""
+        evaluator = SCRIPTS_DIR / "compression_evaluator.py"
+        analyzer = SCRIPTS_DIR / "context_analyzer.py"
+
+        eval_content = evaluator.read_text()
+        analyzer_content = analyzer.read_text()
+
+        assert "MAX_FILE_SIZE_MB = 100" in eval_content
+        assert "MAX_FILE_SIZE_MB = 100" in analyzer_content
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/templates/skills/cook/README.md

@@ -0,0 +1,86 @@
+# Cook Skill
+
+End-to-end feature implementation with smart intent detection.
+
+## Installation
+
+Copy the `cook/` folder to your Claude skills directory:
+```bash
+cp -r cook ~/.claude/skills/
+```
+
+## Usage
+
+```bash
+/cook <natural language task OR plan path>
+```
+
+The skill automatically detects your intent and routes to the appropriate workflow.
+
+## Examples
+
+```bash
+# Interactive mode (default)
+/cook implement user authentication
+
+# Execute existing plan
+/cook plans/260120-auth
+
+# Fast mode (skip research)
+/cook quick fix for login bug
+/cook implement feature --fast
+
+# Auto mode (trust me bro)
+/cook implement dashboard trust me
+/cook implement feature --auto
+
+# Parallel mode (multi-agent)
+/cook implement auth, payments, notifications
+/cook implement feature --parallel
+
+# No-test mode
+/cook implement feature --no-test
+```
+
+## Modes
+
+| Mode | Research | Testing | Review | Use Case |
+|------|----------|---------|--------|----------|
+| interactive | ✓ | ✓ | User approval | Default, full control |
+| auto | ✓ | ✓ | Auto if score≥9.5 | Trusted, hands-off |
+| fast | ✗ | ✓ | Simplified | Quick fixes |
+| parallel | Optional | ✓ | User approval | Multi-feature work |
+| no-test | ✓ | ✗ | User approval | Speed priority |
+| code | ✗ | ✓ | User approval | Existing plans |
+
+## Intent Detection
+
+The skill detects mode from:
+1. **Explicit flags:** `--fast`, `--auto`, `--parallel`, `--no-test`
+2. **Plan paths:** `./plans/*`, `plan.md`, `phase-*.md`
+3. **Keywords:** "fast", "quick", "trust me", "auto", "no test"
+4. **Feature count:** 3+ features → parallel mode
+
+## Workflow
+
+```
+[Intent Detection] → [Research?] → [Plan] → [Implement] → [Test?] → [Review] → [Finalize]
+```
+
+## Files
+
+```
+cook/
+├── SKILL.md                           # Main skill definition
+├── README.md                          # This file
+└── references/
+    ├── intent-detection.md            # Detection rules
+    ├── workflow-steps.md              # Step definitions
+    ├── review-cycle.md                # Review process
+    └── subagent-patterns.md           # Subagent usage
+```
+
+## Version
+
+2.1.0 - Review gates added for human-in-the-loop mode
+2.0.0 - Smart intent detection (hybrid approach)

package/templates/skills/cook/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: ck:cook
+description: "ALWAYS activate this skill before implementing EVERY feature, plan, or fix."
+version: 2.1.1
+argument-hint: "[task|plan-path] [--interactive|--fast|--parallel|--auto|--no-test]"
+---
+
+# Cook - Smart Feature Implementation
+
+End-to-end implementation with automatic workflow detection.
+
+**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports
+
+## Usage
+
+```
+/cook <natural language task OR plan path>
+```
+
+**IMPORTANT:** If no flag is provided, the skill will use the `interactive` mode by default for the workflow.
+
+**Optional flags to select the workflow mode:** 
+- `--interactive`: Full workflow with user input (**default**)
+- `--fast`: Skip research, scout→plan→code
+- `--parallel`: Multi-agent execution
+- `--no-test`: Skip testing step
+- `--auto`: Auto-approve all steps
+
+**Example:**
+```
+/cook "Add user authentication to the app" --fast
+/cook path/to/plan.md --auto
+```
+
+## Smart Intent Detection
+
+| Input Pattern | Detected Mode | Behavior |
+|---------------|---------------|----------|
+| Path to `plan.md` or `phase-*.md` | code | Execute existing plan |
+| Contains "fast", "quick" | fast | Skip research, scout→plan→code |
+| Contains "trust me", "auto" | auto | Auto-approve all steps |
+| Lists 3+ features OR "parallel" | parallel | Multi-agent execution |
+| Contains "no test", "skip test" | no-test | Skip testing step |
+| Default | interactive | Full workflow with user input |
+
+See `references/intent-detection.md` for detection logic.
+
+## Workflow Overview
+
+```
+[Intent Detection] → [Research?] → [Review] → [Plan] → [Review] → [Implement] → [Review] → [Test?] → [Review] → [Finalize]
+```
+
+**Default (non-auto):** Stops at `[Review]` gates for human approval before each major step.
+**Auto mode (`--auto`):** Skips human review gates, implements all phases continuously.
+**Claude Tasks:** Utilize all these tools `TaskCreate`, `TaskUpdate`, `TaskGet` and `TaskList` during implementation step.
+
+| Mode | Research | Testing | Review Gates | Phase Progression |
+|------|----------|---------|--------------|-------------------|
+| interactive | ✓ | ✓ | **User approval at each step** | One at a time |
+| auto | ✓ | ✓ | Auto if score≥9.5 | All at once (no stops) |
+| fast | ✗ | ✓ | **User approval at each step** | One at a time |
+| parallel | Optional | ✓ | **User approval at each step** | Parallel groups |
+| no-test | ✓ | ✗ | **User approval at each step** | One at a time |
+| code | ✗ | ✓ | **User approval at each step** | Per plan |
+
+## Step Output Format
+
+```
+✓ Step [N]: [Brief status] - [Key metrics]
+```
+
+## Blocking Gates (Non-Auto Mode)
+
+Human review required at these checkpoints (skipped with `--auto`):
+- **Post-Research:** Review findings before planning
+- **Post-Plan:** Approve plan before implementation
+- **Post-Implementation:** Approve code before testing
+- **Post-Testing:** 100% pass + approve before finalize
+
+**Always enforced (all modes):**
+- **Testing:** 100% pass required (unless no-test mode)
+- **Code Review:** User approval OR auto-approve (score≥9.5, 0 critical)
+- **Finalize (MANDATORY - never skip):**
+  1. `project-manager` subagent → run full plan sync-back (all completed tasks/steps across all `phase-XX-*.md`, not only current phase), then update `plan.md` status/progress
+  2. `docs-manager` subagent → update `./docs` if changes warrant
+  3. `TaskUpdate` → mark all Claude Tasks complete after sync-back verification
+  4. Ask user if they want to commit via `git-manager` subagent
+
+## Required Subagents (MANDATORY)
+
+| Phase | Subagent | Requirement |
+|-------|----------|-------------|
+| Research | `researcher` | Optional in fast/code |
+| Scout | `ck:scout` | Optional in code |
+| Plan | `planner` | Optional in code |
+| UI Work | `ui-ux-designer` | If frontend work |
+| Testing | `tester`, `debugger` | **MUST** spawn |
+| Review | `code-reviewer` | **MUST** spawn |
+| Finalize | `project-manager`, `docs-manager`, `git-manager` | **MUST** spawn all 3 |
+
+**CRITICAL ENFORCEMENT:**
+- Steps 4, 5, 6 **MUST** use Task tool to spawn subagents
+- DO NOT implement testing, review, or finalization yourself - DELEGATE
+- If workflow ends with 0 Task tool calls, it is INCOMPLETE
+- Pattern: `Task(subagent_type="[type]", prompt="[task]", description="[brief]")`
+
+## References
+
+- `references/intent-detection.md` - Detection rules and routing logic
+- `references/workflow-steps.md` - Detailed step definitions for all modes
+- `references/review-cycle.md` - Interactive and auto review processes
+- `references/subagent-patterns.md` - Subagent invocation patterns

package/templates/skills/cook/references/intent-detection.md

@@ -0,0 +1,101 @@
+# Intent Detection Logic
+
+Detect user intent from natural language and route to appropriate workflow.
+
+## Detection Algorithm
+
+```
+FUNCTION detectMode(input):
+  # Priority 1: Explicit flags (override all)
+  IF input contains "--fast": RETURN "fast"
+  IF input contains "--parallel": RETURN "parallel"
+  IF input contains "--auto": RETURN "auto"
+  IF input contains "--no-test": RETURN "no-test"
+
+  # Priority 2: Plan path detection
+  IF input matches path pattern (./plans/*, plan.md, phase-*.md):
+    RETURN "code"
+
+  # Priority 3: Keyword detection (case-insensitive)
+  keywords = lowercase(input)
+
+  IF keywords contains ["fast", "quick", "rapidly", "asap"]:
+    RETURN "fast"
+
+  IF keywords contains ["trust me", "auto", "yolo", "just do it"]:
+    RETURN "auto"
+
+  IF keywords contains ["no test", "skip test", "without test"]:
+    RETURN "no-test"
+
+  # Priority 4: Complexity detection
+  features = extractFeatures(input)  # comma-separated or "and"-joined items
+  IF count(features) >= 3 OR keywords contains "parallel":
+    RETURN "parallel"
+
+  # Default: interactive workflow
+  RETURN "interactive"
+```
+
+## Feature Extraction
+
+Detect multiple features from natural language:
+
+```
+"implement auth, payments, and notifications" → ["auth", "payments", "notifications"]
+"add login + signup + password reset"        → ["login", "signup", "password reset"]
+"create dashboard with charts and tables"    → single feature (dashboard)
+```
+
+**Parallel trigger:** 3+ distinct features = parallel mode
+
+## Mode Behaviors
+
+| Mode | Skip Research | Skip Test | Review Gates | Auto-Approve | Parallel Exec |
+|------|---------------|-----------|--------------|--------------|---------------|
+| interactive | ✗ | ✗ | **Yes (stops)** | ✗ | ✗ |
+| auto | ✗ | ✗ | **No (skips)** | ✓ (score≥9.5) | ✓ (all phases) |
+| fast | ✓ | ✗ | Yes (stops) | ✗ | ✗ |
+| parallel | Optional | ✗ | Yes (stops) | ✗ | ✓ |
+| no-test | ✗ | ✓ | Yes (stops) | ✗ | ✗ |
+| code | ✓ | ✗ | Yes (stops) | Per plan | Per plan |
+
+**Review Gates:** Human approval checkpoints between major steps (see `workflow-steps.md`).
+- All modes EXCEPT `auto` stop at review gates for human approval.
+- `auto` mode is the only mode that runs continuously without stopping.
+
+## Examples
+
+```
+"/cook implement user auth"
+→ Mode: interactive (default, stops at review gates)
+
+"/cook plans/260120-auth/phase-02-api.md"
+→ Mode: code (path detected, stops at review gates)
+
+"/cook quick fix for the login bug"
+→ Mode: fast ("quick" keyword, stops at review gates)
+
+"/cook implement auth, payments, notifications, shipping"
+→ Mode: parallel (4 features, stops at review gates)
+
+"/cook implement dashboard --fast"
+→ Mode: fast (explicit flag, stops at review gates)
+
+"/cook implement everything --auto"
+→ Mode: auto (NO STOPS, implements all phases continuously)
+
+"/cook implement dashboard trust me"
+→ Mode: auto ("trust me" keyword, NO STOPS)
+```
+
+**Note:** Only `--auto` flag or "trust me"/"auto"/"yolo" keywords enable continuous execution.
+
+## Conflict Resolution
+
+When multiple signals detected, priority order:
+1. Explicit flags (`--fast`, `--auto`, etc.)
+2. Path detection (plan files)
+3. Keywords in text
+4. Feature count analysis
+5. Default (interactive)

package/templates/skills/cook/references/review-cycle.md

@@ -0,0 +1,75 @@
+# Code Review Cycle
+
+Interactive review-fix cycle used in code workflows.
+
+## Interactive Cycle (max 3 cycles)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings, suggestions
+
+  2. DISPLAY FINDINGS:
+     ┌─────────────────────────────────────────┐
+     │ Code Review Results: [score]/10         │
+     ├─────────────────────────────────────────┤
+     │ Summary: [what implemented], tests      │
+     │ [X/X passed]                            │
+     ├─────────────────────────────────────────┤
+     │ Critical Issues ([N]): MUST FIX         │
+     │  - [issue] at [file:line]               │
+     │ Warnings ([N]): SHOULD FIX              │
+     │  - [issue] at [file:line]               │
+     │ Suggestions ([N]): NICE TO HAVE         │
+     │  - [suggestion]                         │
+     └─────────────────────────────────────────┘
+
+  3. AskUserQuestion (header: "Review & Approve"):
+     IF critical_count > 0:
+       - "Fix critical issues" → fix, re-run tester, cycle++, LOOP
+       - "Fix all issues" → fix all, re-run tester, cycle++, LOOP
+       - "Approve anyway" → PROCEED
+       - "Abort" → stop
+     ELSE:
+       - "Approve" → PROCEED
+       - "Fix warnings/suggestions" → fix, cycle++, LOOP
+       - "Abort" → stop
+
+  4. IF cycle >= 3 AND user selects fix:
+     → "⚠ 3 review cycles completed. Final decision required."
+     → AskUserQuestion: "Approve with noted issues" / "Abort workflow"
+```
+
+## Auto-Handling Cycle (for auto modes)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings
+
+  2. IF score >= 9.5 AND critical_count == 0:
+     → Auto-approve, PROCEED
+
+  3. ELSE IF critical_count > 0 AND cycle < 3:
+     → Auto-fix critical issues
+     → Re-run tester
+     → cycle++, LOOP
+
+  4. ELSE IF critical_count > 0 AND cycle >= 3:
+     → ESCALATE TO USER
+
+  5. ELSE (no critical, score < 9.5):
+     → Approve with warnings logged, PROCEED
+```
+
+## Critical Issues Definition
+- Security: XSS, SQL injection, OWASP vulnerabilities
+- Performance: bottlenecks, inefficient algorithms
+- Architecture: violations of patterns, coupling
+- Principles: YAGNI, KISS, DRY violations
+
+## Output Formats
+- Waiting: `⏸ Step 4: Code reviewed - [score]/10 - WAITING for approval`
+- After fix: `✓ Step 4: [old]/10 → Fixed [N] issues → [new]/10 - Approved`
+- Auto-approved: `✓ Step 4: Code reviewed - 9.8/10 - Auto-approved`
+- Approved: `✓ Step 4: Code reviewed - [score]/10 - User approved`