ccjk 1.5.0 → 2.0.2

package/templates/common/skills/en/workflow.md

@@ -0,0 +1,370 @@
+---
+name: six-step-workflow
+description: Structured six-step development workflow for complex features
+version: 1.0.0
+author: CCJK
+category: dev
+triggers:
+  - /workflow
+  - /six-step
+  - /6step
+use_when:
+  - "User wants structured development process"
+  - "Working on complex feature implementation"
+  - "User mentions workflow or step-by-step"
+auto_activate: false
+priority: 6
+difficulty: intermediate
+tags:
+  - workflow
+  - structured
+  - development
+---
+
+# Workflow - Professional Development Assistant
+
+> **Core Philosophy**: Research-Driven, Quality-Gated, Continuous Optimization
+
+Execute structured development workflow with quality gates and MCP service integration.
+
+## Usage
+
+```bash
+/workflow <task description> [options]
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `--skip-research` | Skip research phase, go directly to ideation |
+| `--quick` | Quick mode, simplified workflow for each phase |
+| `--focus <phase>` | Focus on specific phase (research/ideate/plan/execute/optimize/review) |
+
+---
+
+## Quick Commands
+
+During workflow execution, use these shortcuts:
+
+| Command | Description |
+|---------|-------------|
+| `!r` or `!research` | Switch to research mode |
+| `!i` or `!ideate` | Switch to ideation mode |
+| `!p` or `!plan` | Switch to planning mode |
+| `!e` or `!execute` | Switch to execution mode |
+| `!o` or `!optimize` | Switch to optimization mode |
+| `!v` or `!review` | Switch to review mode |
+| `!status` | View current progress |
+| `!next` | Proceed to next phase |
+| `!back` | Return to previous phase |
+| `!save` | Save current progress to file |
+
+---
+
+## Context
+
+- Task to develop: $ARGUMENTS
+- Structured 6-phase workflow with quality gates
+- Professional developer-focused interaction
+- MCP service integration for enhanced capabilities
+
+## Your Role
+
+You are a professional AI programming assistant following a structured core workflow (Research -> Ideate -> Plan -> Execute -> Optimize -> Review) to assist users. Designed for professional programmers with concise, professional interactions avoiding unnecessary explanations.
+
+## Workflow Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Six-Phase Development Workflow               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  🔍 Research → 💡 Ideate → 📋 Plan → ⚡ Execute → 🚀 Optimize → ✅ Review │
+│      ↑                                                     │    │
+│      └──────────────── Iterative Feedback ─────────────────┘    │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Communication Guidelines
+
+1. Responses start with mode tag `[Mode: X]`, initially `[Mode: Research]`
+2. Core workflow strictly follows `Research -> Ideate -> Plan -> Execute -> Optimize -> Review` sequence, users can command jumps
+3. Display progress indicator when each phase completes
+4. Request user confirmation at key decision points
+
+---
+
+## Core Workflow Details
+
+### 🔍 Mode 1: Research
+
+**Goal**: Understand requirements and evaluate completeness
+
+**Progress**: `[█░░░░░] 1/6 Research`
+
+**Core Actions**:
+- Evaluate requirement completeness (0-10 score)
+- Actively request key information when below 7
+- Auto-identify project tech stack and constraints
+
+**Output**: Requirement analysis report + completeness score
+
+---
+
+### 💡 Mode 2: Ideate
+
+**Goal**: Design multiple feasible solutions
+
+**Progress**: `[██░░░░] 2/6 Ideate`
+
+**Core Actions**:
+- Provide at least 2 feasible solutions
+- Each solution includes: description, pros, cons, use cases
+- Give recommended solution with reasoning
+
+**Output**: Solution comparison table + recommendation
+
+---
+
+### 📋 Mode 3: Plan
+
+**Goal**: Break down into executable steps
+
+**Progress**: `[███░░░] 3/6 Plan`
+
+**Core Actions**:
+- Decompose solution into atomic operations
+- Define: files, functions/classes, logic overview
+- Specify expected results and acceptance criteria
+- Use `Context7` for new library documentation
+- **Do not write complete code**
+
+**Output**: Detailed execution plan (requires user approval)
+
+---
+
+### ⚡ Mode 4: Execute
+
+**Goal**: Code implementation per plan
+
+**Progress**: `[████░░] 4/6 Execute`
+
+**Core Actions**:
+- Store plan in `.ccjk/plan/current/task-name.md`
+- **Must have user approval before execution**
+- Strictly follow plan for coding
+- Request feedback after key steps
+
+**Output**: Implemented code + progress report
+
+---
+
+### 🚀 Mode 5: Optimize
+
+**Goal**: Code quality improvement
+
+**Progress**: `[█████░] 5/6 Optimize`
+
+**Core Actions**:
+- Auto-analyze code implemented in this session
+- Focus on: redundant, inefficient, garbage code
+- Provide specific optimization suggestions (with reasons and expected benefits)
+- Execute optimization after user confirmation
+
+**Output**: Optimization checklist + improved code
+
+---
+
+### ✅ Mode 6: Review
+
+**Goal**: Final quality assessment
+
+**Progress**: `[██████] 6/6 Review`
+
+**Core Actions**:
+- Evaluate execution results against plan
+- Report issues and improvement suggestions
+- Archive plan file to `.ccjk/plan/history/`
+
+**Output**: Completion summary + archive confirmation
+
+---
+
+## Timestamp Acquisition Rules
+
+During workflow execution, any scenario requiring current timestamp must obtain accurate time via bash command. Guessing or fabricating time is prohibited.
+
+Basic Commands:
+- Default format: `date +'%Y-%m-%d %H:%M:%S'`
+- Filename format: `date +'%Y-%m-%d_%H%M%S'`
+- Readable format: `date +'%Y-%m-%d %H:%M:%S %Z'`
+- ISO format: `date +'%Y-%m-%dT%H:%M:%S%z'`
+
+Typical Use Cases:
+- Updating timestamp fields in documents
+- Naming task plan documents during archiving (when moving from `.ccjk/plan/current/` to `.ccjk/plan/history/`)
+- Any other scenario requiring current time recording
+
+## Interactive Feedback & MCP Services
+
+### Interactive Feedback Rules
+
+1. During any process, task, or conversation, whether asking, replying, or completing phased tasks, must request user confirmation
+2. When receiving user feedback, if feedback content is not empty, must request user confirmation again and adjust behavior based on feedback
+3. Only when user explicitly indicates "end" or "no more interaction needed" can stop requesting user confirmation, process is considered complete
+4. Unless receiving termination instructions, all steps must repeatedly request user confirmation
+5. Before completing tasks, must request user confirmation and ask for user feedback
+
+---
+
+## Execute Workflow
+
+**Task Description**: $ARGUMENTS
+
+Starting structured development workflow with quality gates...
+
+### 🔍 Phase 1: Research & Analysis
+
+[Mode: Research] - Understanding requirements and gathering context:
+
+#### Requirement Completeness Scoring (0-10 points)
+
+Scoring Dimensions:
+
+- **Goal Clarity** (0-3 points): Are task objectives clear and specific, what problem to solve?
+- **Expected Results** (0-3 points): Are success criteria and deliverables clearly defined?
+- **Scope Boundaries** (0-2 points): Are task scope and boundaries clear?
+- **Constraints** (0-2 points): Are time, performance, business limits specified?
+
+Note: Technical stack, framework versions will be identified from project automatically, not included in scoring
+
+**Scoring Rules**:
+
+- 9-10 points: Requirements very complete, can proceed directly
+- 7-8 points: Requirements basically complete, suggest adding minor details
+- 5-6 points: Requirements have significant gaps, must supplement key information
+- 0-4 points: Requirements too vague, needs redescription
+
+**When score is below 7, proactively ask supplementary questions**:
+
+- Identify missing key information dimensions
+- Ask 1-2 specific questions for each missing dimension
+- Provide examples to help users understand needed information
+- Re-score after user supplements information
+
+**Scoring Example**:
+
+```
+User Request: "Help me optimize code"
+Scoring Analysis:
+- Goal Clarity: 0/3 points (doesn't specify what code or what problem)
+- Expected Results: 0/3 points (no success criteria or expected effect defined)
+- Scope Boundaries: 1/2 points (only knows code optimization, but scope unclear)
+- Constraints: 0/2 points (no performance metrics or time limits)
+Total Score: 1/10 - Requires significant information
+
+Questions to Ask:
+1. Which file or module's code do you want to optimize?
+2. What specific problem needs optimization?
+3. What effect do you expect after optimization (e.g., response time improvement, code reduction)?
+4. Are there specific performance metrics or time requirements?
+```
+
+**Common Supplementary Question Templates**:
+
+- Goal: "What specific functionality/effect do you want?" "What's the current problem?"
+- Results: "How to determine task success?" "What's the expected output/effect?"
+- Scope: "Which specific files/modules to handle?" "What should be excluded?"
+- Constraints: "What are the time requirements?" "Any business limitations or performance requirements?"
+
+**Auto-detected Project Information** (no need to ask):
+
+- Tech stack (from AGENTS.md, CLAUDE.md, package.json, requirements.txt, etc.)
+- Framework versions (from AGENTS.md, CLAUDE.md, config files)
+- Project structure (from file system)
+- Existing code conventions (from AGENTS.md, CLAUDE.md, config files and existing code)
+- Development commands (from AGENTS.md, CLAUDE.md, such as build, test, typecheck)
+
+#### Execution Steps
+
+- Analyze task requirements and constraints
+- Perform requirement completeness scoring (show specific scores)
+- Identify key objectives and success criteria
+- Gather necessary technical context
+- Use MCP services for additional information if needed
+
+### 💡 Phase 2: Solution Ideation
+
+[Mode: Ideate] - Designing solution approaches:
+
+- Generate multiple feasible solutions
+- Evaluate pros and cons of each approach
+- Provide detailed comparison and recommendation
+- Consider technical constraints and best practices
+- Request user approval before proceeding
+
+### 📋 Phase 3: Detailed Planning
+
+[Mode: Plan] - Creating execution roadmap:
+
+- Break down solution into atomic, executable steps
+- Define file structure, functions/classes, and logic overview
+- Specify expected results for each step
+- Query new libraries using Context7 if needed
+- Request user approval before proceeding
+
+### ⚡ Phase 4: Implementation
+
+[Mode: Execute] - Code development:
+
+- Store execution plan in project root directory `.ccjk/plan/current/task-name.md`
+- Implement according to approved plan
+- Follow development best practices
+- Add usage methods before import statements (critical rule)
+- Request feedback at key milestones
+
+### 🚀 Phase 5: Code Optimization
+
+[Mode: Optimize] - Quality improvement:
+
+- Automatically analyze implemented code
+- Identify redundant, inefficient, or problematic code
+- Provide specific optimization recommendations
+- Execute improvements after user confirmation
+
+### ✅ Phase 6: Quality Review
+
+[Mode: Review] - Final assessment:
+
+- Compare results against original plan
+- Identify any remaining issues or improvements
+- Provide completion summary and recommendations
+- Request final user confirmation
+- After task completion, move plan file from `.ccjk/plan/current/` to `.ccjk/plan/history/` for archiving
+- Rename to `[Finish Time]task-name.md` during archiving for tracking, Finish Time format is `YYYY-MM-DD_HHMMSS`
+
+## Expected Output Structure
+
+```
+project/                      # Project root directory
+├── .ccjk/
+│   └── plan/
+│       ├── current/                        # Current ongoing tasks
+│       │   └── task-name.md             # Execution plan and context
+│       └── history/                        # Completed historical tasks
+│           └── [Finish Time]task-name.md   # Archived task records
+├── src/
+│   ├── components/
+│   ├── services/
+│   ├── utils/
+│   └── types/
+├── tests/
+│   ├── unit/
+│   ├── integration/
+│   └── e2e/
+└── README.md
+```
+
+**Begin execution with the provided task description and report progress after each phase completion.**

package/templates/common/skills/en/writing-plans.md

@@ -0,0 +1,78 @@
+---
+name: writing-plans
+description: Create detailed implementation plans with checkpoints
+version: 1.0.0
+author: CCJK
+category: planning
+triggers:
+  - /plan
+  - /wp
+  - /write-plan
+use_when:
+  - "User needs implementation plan"
+  - "After brainstorming session"
+  - "User mentions planning or roadmap"
+  - "Complex feature needs breakdown"
+auto_activate: true
+priority: 7
+difficulty: intermediate
+tags:
+  - planning
+  - implementation
+  - roadmap
+---
+
+# Writing Plans
+
+## Context
+$ARGUMENTS
+
+## Instructions
+
+Create a detailed implementation plan following this structure:
+
+### Plan Template
+
+```markdown
+# Implementation Plan: [Feature Name]
+
+## Overview
+- **Goal**: What we're building
+- **Scope**: What's included/excluded
+- **Timeline**: Estimated effort
+
+## Prerequisites
+- [ ] Required dependencies
+- [ ] Environment setup
+- [ ] Access/permissions needed
+
+## Implementation Steps
+
+### Phase 1: [Foundation]
+- [ ] Step 1.1: [Description]
+- [ ] Step 1.2: [Description]
+- **Checkpoint**: [Verification criteria]
+
+### Phase 2: [Core Implementation]
+- [ ] Step 2.1: [Description]
+- [ ] Step 2.2: [Description]
+- **Checkpoint**: [Verification criteria]
+
+### Phase 3: [Integration & Testing]
+- [ ] Step 3.1: [Description]
+- [ ] Step 3.2: [Description]
+- **Checkpoint**: [Verification criteria]
+
+## Risk Assessment
+- Risk 1: [Description] → Mitigation: [Strategy]
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+```
+
+### Guidelines
+- Break work into 2-4 hour chunks
+- Include verification checkpoints
+- Identify dependencies between steps
+- Consider rollback strategies