cokit-cli 1.0.8 → 1.2.0

package/prompts/ck-plan-hard.prompt.md

@@ -1,11 +1,12 @@
 ---
 agent: 'agent'
 description: 'Research, analyze, and create an implementation plan'
-tools: ['search/codebase', 'search/changes', 'web/fetch', 'read/problems']
+argument-hint: 'Task description or requirements'
+tools: ['web/fetch', 'search/codebase', 'read/readFile', 'search/listDirectory', 'edit/createFile', 'edit/editFiles']
 ---
 
 Think harder.
-
+Activate `planning` skill.
 
 ## Your mission
 <task>
@@ -20,27 +21,40 @@ Check the `## Plan Context` section in the injected context:
 - If "Plan: none" → Create new plan using naming from `## Naming` section.
 
 ## Workflow
-1. If creating new: Create directory using `Plan dir:` from `## Naming` section, then run `node  {plan-dir}`
+1. If creating new: Create directory using `Plan dir:` from `## Naming` section, then run `node $HOME/.copilot/scripts/set-active-plan.cjs {plan-dir}`
    If reusing: Use the active plan path from Plan Context.
-   Make sure you pass the directory path to every  during the process.
+   Make sure you pass the directory path to every subagent during the process.
 2. Follow strictly to the "Plan Creation & Organization" rules of `planning` skill.
-3. Use multiple `researcher` agents (max 2 agents)  to research for this task:
+3. Use multiple `researcher` agents (max 2 agents) in parallel to research for this task:
    Each agent research for a different aspect of the task and are allowed to perform max 5 tool calls.
-4. Analyze the codebase by reading `codebase-summary.md`, ``, `system-architecture.md` and `project-overview-pdr.md` file.
-   **ONLY PERFORM THIS FOLLOWING STEP IF `codebase-summary.md` is not available or older than 3 days**: Use  <instructions>`  to search the codebase for files needed to complete the task.
-5. 
-6. 
+4. Analyze the codebase by reading `codebase-summary.md`, `code-standards.md`, `system-architecture.md` and `project-overview-pdr.md` file.
+   **ONLY PERFORM THIS FOLLOWING STEP IF `codebase-summary.md` is not available or older than 3 days**: Use `/scout <instructions>` slash command to search the codebase for files needed to complete the task.
+5. Main agent gathers all research and scout report filepaths, and pass them to `planner` subagent with the prompt to create an implementation plan of this task.
+6. Main agent receives the implementation plan from `planner` subagent, and ask user to review the plan
+
+## Post-Plan Validation (Optional)
+
+After plan creation, offer validation interview to confirm decisions before implementation.
 
 **Check `## Plan Context` → `Validation: mode=X, questions=MIN-MAX`:**
 
 | Mode | Behavior |
 |------|----------|
 | `prompt` | Ask user: "Validate this plan with a brief interview?" → Yes (Recommended) / No |
-| `auto` | Automatically execute :validate {plan-path}` |
+| `auto` | Automatically execute `/ck.plan:validate {plan-path}` |
 | `off` | Skip validation step entirely |
 
-**If mode is `prompt`:** Ask user with options above.
-**If user chooses validation or mode is `auto`:** Execute :validate {plan-path}` SlashCommand.
+**If mode is `prompt`:** Use `AskUserQuestion` tool with options above.
+**If user chooses validation or mode is `auto`:** Execute `/ck.plan:validate {plan-path}` SlashCommand.
+
+## Context Reminder (MANDATORY)
+
+**IMPORTANT:** If user skips validation (chooses "No" or mode is `off`), you MUST remind them:
+
+> **Best Practice:** Run `/clear` before implementing to start with fresh context.
+> Then run `/cook {plan-path}` to begin implementation.
+
+This reminder is **NON-NEGOTIABLE** when validation is skipped.
 
 ## Output Requirements
 
@@ -78,48 +92,21 @@ Check the `## Plan Context` section in the injected context:
   created: {YYYY-MM-DD}
   ---
   ```
-- Save the overview access point at `{plan-dir}.md`. Keep it generic, under 80 lines, and list each implementation phase with status and progress plus links to phase files.
+- Save the overview access point at `{plan-dir}/ck.plan.md`. Keep it generic, under 80 lines, and list each implementation phase with status and progress plus links to phase files.
 - For each phase, create `{plan-dir}/phase-XX-phase-name-here.md` containing the following sections in order: Context links (reference parent plan, dependencies, docs), Overview (date, description, priority, implementation status, review status), Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps.
 
-## Clarification & Finalization Flow
-
-After creating the initial plan:
-
-1. **If questions exist** → List questions at the end of your response (max 3-5 questions)
-2. **After user answers** → Update `plan.md` with clarified requirements
-3. **Repeat** until no ambiguities remain
-4. **Finalize** → Confirm plan is complete and ready for implementation
-
-**Question format:**
-```
-## Questions before finalizing:
-1. [Question 1]?
-2. [Question 2]?
-...
-```
-
-## Next Steps Suggestion
-
-After plan is finalized, suggest the appropriate implementation command:
-
-| Task Type | Suggested Command |
-|-----------|-------------------|
-| Feature development | `/cook` or `/code` |
-| Bug fix | `/fix` |
-| Refactoring | `/refactor` |
-| Documentation | `/docs` |
+## Important Notes
+**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+**IMPORTANT:** Ensure token efficiency while maintaining high quality.
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+**IMPORTANT**: **Do not** start implementing.
 
-**Example output:**
-```
-✅ Plan finalized: {plan-dir}/plan.md
+---
 
-Ready to implement? Run one of these:
-- `/cook` - Full-featured implementation with tests
-- `/code` - Quick implementation
-```
+## Suggested Next Steps
 
-## Important Notes
-- **IMPORTANT:** Ensure token efficiency while maintaining high quality.
-- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
-- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
-- **IMPORTANT:** **Do not** start implementing.
+| Command | Description |
+|---------|-------------|
+| `/ck.test` | Run tests and analyze results |
+| `/ck.fix` | Analyze and fix issues |

package/prompts/ck-plan.prompt.md

@@ -1,7 +1,7 @@
 ---
 agent: 'agent'
 description: 'Intelligent plan creation with prompt enhancement'
-tools: ['search/codebase', 'search/changes', 'web/fetch', 'read/problems']
+argument-hint: 'Task description or requirements'
 ---
 
 ## Your mission
@@ -17,64 +17,22 @@ Check the `## Plan Context` section in the injected context:
 - If "Plan: none" → Proceed to create new plan using naming pattern from `## Naming` section.
 
 ## Workflow
-- Analyze the given task and ask user for more details if needed.
-- Decide complexity:
-  - **Simple task** (clear scope, no research needed) → Use `/plan:fast`
-  - **Complex task** (needs research, multiple aspects) → Use `/plan:hard`
-- Execute the chosen SlashCommand with an **enhanced detailed prompt**:
-  - `/plan:fast <detailed-instructions-prompt>`
-  - `/plan:hard <detailed-instructions-prompt>`
+- Analyze the given task and use `AskUserQuestion` tool to ask for more details if needed.
+- Activate `planning` skill.
+- Note: `detailed-instructions-prompt` is **an enhanced prompt** that describes the task in detail based on the provided task description.
 
-**Note:** The `detailed-instructions-prompt` must describe the task in detail based on user's input.
-
-## Output
-The output MUST be markdown plan files saved to `plans/` directory:
-```
-{plan-dir}/
-├── plan.md              ← Main plan with YAML frontmatter
-├── phase-XX-*.md        ← Implementation phases
-└── reports/             ← Any analysis reports
-```
-
-## Clarification & Finalization Flow
-
-After creating the initial plan:
-
-1. **If questions exist** → List questions at the end of your response (max 3-5 questions)
-2. **After user answers** → Update `plan.md` with clarified requirements
-3. **Repeat** until no ambiguities remain
-4. **Finalize** → Confirm plan is complete and ready for implementation
-
-**Question format:**
-```
-## Questions before finalizing:
-1. [Question 1]?
-2. [Question 2]?
-...
-```
-
-## Next Steps Suggestion
-
-After plan is finalized, suggest the appropriate implementation command:
-
-| Task Type | Suggested Command |
-|-----------|-------------------|
-| Feature development | `/cook` or `/code` |
-| Bug fix | `/fix` |
-| Refactoring | `/refactor` |
-| Documentation | `/docs` |
+## Important Notes
+**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** Ensure token efficiency while maintaining high quality.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+**IMPORTANT**: **Do not** start implementing.
 
-**Example output:**
-```
-✅ Plan finalized: {plan-dir}/plan.md
+---
 
-Ready to implement? Run one of these:
-- `/cook` - Full-featured implementation with tests
-- `/code` - Quick implementation
-```
+## Suggested Next Steps
 
-## Important Notes
-- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
-- **IMPORTANT:** Ensure token efficiency while maintaining high quality.
-- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
-- **IMPORTANT:** **Do not** start implementing.
+| Command | Description |
+|---------|-------------|
+| `/ck.test` | Run tests and analyze results |
+| `/ck.fix` | Analyze and fix issues |

package/prompts/ck-preview.prompt.md

@@ -1,41 +1,40 @@
 ---
 agent: 'agent'
-description: 'Path to file or directory to preview'
-tools: ['search/codebase', 'read/terminalLastCommand']
+description: 'Preview markdown files, plan directories, or plans collection'
+argument-hint: 'Path to markdown file or directory'
+tools: ['execute/runInTerminal', 'execute/getTerminalOutput']
 ---
 
 Universal viewer using `markdown-novel-viewer` skill - pass ANY path and see it rendered nicely.
 
 ## Usage
 
-- `/preview <file.md>` - View markdown file in novel-reader UI
-- `/preview <directory/>` - Browse directory contents
-- `/preview --stop` - Stop running server
+- `/ck.preview <file.md>` - View markdown file in novel-reader UI
+- `/ck.preview <directory/>` - Browse directory contents
+- `/ck.preview --stop` - Stop running server
 
 ## Examples
 
 ```bash
-/preview plans/my-plan.md     # View markdown file
-/preview plans/                    # Browse plans directory
-/preview docs/                     # Browse docs directory
-/preview any/path/to/file.md      # View any markdown file
-/preview any/path/                 # Browse any directory
+/ck.preview plans/my-plan/ck.plan.md     # View markdown file
+/ck.preview plans/                    # Browse plans directory
+/ck.preview docs/                     # Browse docs directory
+/ck.preview any/path/to/file.md      # View any markdown file
+/ck.preview any/path/                 # Browse any directory
 ```
 
 ## Execution
 
-**IMPORTANT:**  This makes the server visible in `/tasks` and manageable via `KillShell`.
+**IMPORTANT:** Run server as Claude Code background task using `run_in_background: true` with the Bash tool. This makes the server visible in `/tasks` and manageable via `KillShell`.
 
-Check if this script is located in the current workspace or in  directory:
-- If in current workspace: `$SKILL_DIR_PATH` = 
-- If in home directory: `$SKILL_DIR_PATH` = 
+The skill is located at `$HOME/.copilot/skills/markdown-novel-viewer/`.
 
 ### Stop Server
 
 If `--stop` flag is provided:
 
 ```bash
-node $SKILL_DIR_PATH/scripts/server.cjs --stop
+node $HOME/.copilot/skills/markdown-novel-viewer/scripts/server.cjs --stop
 ```
 
 ### Start Server
@@ -44,17 +43,17 @@ Otherwise, run the `markdown-novel-viewer` server as CC background task with `--
 
 ```bash
 # Determine if path is file or directory
-INPUT_PATH="${path}"
+INPUT_PATH="{{path}}"
 if [[ -d "$INPUT_PATH" ]]; then
   # Directory mode - browse
-  node $SKILL_DIR_PATH/scripts/server.cjs \
+  node $HOME/.copilot/skills/markdown-novel-viewer/scripts/server.cjs \
     --dir "$INPUT_PATH" \
     --host 0.0.0.0 \
     --open \
     --foreground
 else
   # File mode - view markdown
-  node $SKILL_DIR_PATH/scripts/server.cjs \
+  node $HOME/.copilot/skills/markdown-novel-viewer/scripts/server.cjs \
     --file "$INPUT_PATH" \
     --host 0.0.0.0 \
     --open \
@@ -62,4 +61,33 @@ else
 fi
 ```
 
-**Critical:** 
+**Critical:** When calling the Bash tool:
+- Set `run_in_background: true` to run as CC background task
+- Set `timeout: 300000` (5 minutes) to prevent premature termination
+- Parse JSON output and report URL to user
+
+Example Bash tool call:
+```json
+{
+  "command": "node $HOME/.copilot/skills/markdown-novel-viewer/scripts/server.cjs --dir \"path\" --host 0.0.0.0 --open --foreground",
+  "run_in_background": true,
+  "timeout": 300000,
+  "description": "Start preview server in background"
+}
+```
+
+After starting, parse the JSON output (e.g., `{"success":true,"url":"http://localhost:3456/view?file=...","networkUrl":"http://192.168.1.x:3456/view?file=..."}`) and report:
+- Local URL for browser access
+- Network URL for remote device access (if available)
+- Inform user that server is now running as CC background task (visible in `/tasks`)
+
+**CRITICAL:** MUST display the FULL URL including path and query string (e.g., `http://localhost:3456/view?file=/path/to/file.md`). NEVER truncate to just `host:port` (e.g., `http://localhost:3456`). The full URL is required for direct file access.
+
+---
+
+## Suggested Next Steps
+
+| Command | Description |
+|---------|-------------|
+| `/ck.brainstorm` | Explore ideas |
+| `/ck.plan` | Create plan |

package/prompts/ck-review.prompt.md

@@ -0,0 +1,59 @@
+---
+agent: 'agent'
+description: 'Scan and analyze the codebase'
+argument-hint: 'Tasks or prompt to review'
+---
+
+Think harder to scan the codebase and analyze it follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules: 
+<tasks>${input}</tasks>
+
+---
+
+## Role Responsibilities
+- You are an elite software engineering expert who specializes in system architecture design and technical decision-making. 
+- You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+---
+
+## Workflow:
+
+**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+
+### Research
+
+* Use 2 `researcher` subagents in parallel to search up to max 5 sources for the user's request, idea validation, best practices, challenges, and find the best possible solutions.
+* Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
+* Use `/scout:ext` (preferred) or `/scout` (fallback) slash command to search the codebase for files needed to complete the task
+
+### Code Review
+
+* After finishing, use multiple `code-reviewer` subagents in parallel to review code. 
+* If there are any issues, duplicate code, or security vulnerabilities, ask main agent to improve the code and repeat the "Testing" process until all tests pass. 
+* When all tests pass, code is reviewed, the tasks are completed, report back to user with a summary of the changes and explain everything briefly, ask user to review the changes and approve them.
+* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+### Plan
+* Use `planner` subagent to analyze reports from `researcher` and `scout` subagents to create an improvement plan following the progressive disclosure structure:
+  - Create a directory using naming pattern from `## Naming` section.
+  - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
+  - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
+
+### Final Report
+* Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
+* Ask the user if they want to commit and push to git repository, if yes, use `git-manager` subagent to commit and push to git repository.
+
+**REMEMBER**:
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.
+- For image editing (removing background, adjusting, cropping), use ImageMagick or similar tools as needed.
+
+---
+
+## Suggested Next Steps
+
+| Command | Description |
+|---------|-------------|
+| `/ck.brainstorm` | Explore ideas |
+| `/ck.plan` | Create plan |

package/prompts/ck-scout.prompt.md

@@ -1,25 +1,84 @@
----
-agent: 'agent'
-description: 'Scout given directories to respond to the user\'s requests'
-tools: ['search/codebase', 'search/changes']
----
-
-## Purpose
-
-Search the codebase for files needed to complete the task using a fast, token efficient agent.
-
-## Variables
-
-USER_PROMPT: $1
-SCALE: $2 (defaults to 3)
-REPORT_OUTPUT_DIR: Use `Report:` from `## Naming` section
-
-## Workflow:
-- IMPORTANT: Kick these agents off  using the , analyze and divide folders for each agent to scout intelligently and quickly.
-- IMPORTANT: Instruct the agents to quickly search the codebase for files needed to complete the task. This isn't about a full blown search, just a quick search to find the files needed to complete the task.
-- Instruct the  use a timeout of 3 minutes for each agent's bash call. Skip any agents that don't return within the timeout, don't restart them.
-
-**How to write reports:**
-
-- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
-- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+---
+agent: 'agent'
+description: 'Fast codebase scouting using parallel agents'
+argument-hint: 'Search target or keyword'
+tools: ['search/codebase', 'read/readFile', 'search/listDirectory', 'search/textSearch', 'search/fileSearch']
+---
+
+## Context
+Search target:
+<target>${input}</target>
+
+## Your Role
+
+Fast, token-efficient codebase scouting to find files needed for tasks.
+
+## When to Use
+
+- Beginning work on feature spanning multiple directories
+- User mentions needing to "find", "locate", or "search for" files
+- Starting debugging session requiring file relationships understanding
+- User asks about project structure or where functionality lives
+- Before changes that might affect multiple codebase parts
+
+## Workflow
+
+### 1. Analyze Task
+- Parse user prompt for search targets
+- Identify key directories, patterns, file types
+- Determine optimal number of parallel searches
+
+### 2. Divide and Conquer
+- Split codebase into logical segments
+- Assign each search specific directories or patterns
+- Ensure no overlap, maximize coverage
+
+### 3. Execute Parallel Searches
+Use Glob and Grep with wide range of patterns:
+- File patterns: `**/*.ts`, `**/*.tsx`, `**/*.md`
+- Content patterns: function names, class names, keywords
+- Directory patterns: `src/`, `lib/`, `components/`
+
+### 4. Collect Results
+- Timeout: 3 minutes per search (skip non-responders)
+- Aggregate findings into single report
+- List unresolved questions at end
+
+## Report Format
+
+```markdown
+# Scout Report
+
+## Relevant Files
+- `path/to/file.ts` - Brief description
+- `path/to/another.ts` - Brief description
+
+## Directory Structure
+- `src/components/` - UI components
+- `src/services/` - Business logic
+
+## Key Findings
+- Pattern X found in Y locations
+- Feature Z implemented in files A, B, C
+
+## Unresolved Questions
+- Any gaps in findings
+```
+
+## Output Requirements
+
+**Be concise and actionable:**
+- List files with brief descriptions
+- Group by functionality or directory
+- Highlight key patterns and relationships
+- Note any gaps or areas needing further investigation
+
+---
+
+## Suggested Next Steps
+
+| Command | Description |
+|---------|-------------|
+| `/ck.plan` | Create implementation plan |
+| `/ck.cook` | Implement feature |
+| `/ck.ask` | Ask technical questions |

package/prompts/ck-simplify.prompt.md

@@ -0,0 +1,46 @@
+---
+agent: 'code-simplifier'
+description: 'Simplify and refine code for clarity and maintainability'
+argument-hint: 'Scope: file path, git diff, or "recent changes"'
+---
+
+## Context
+Scope:
+<scope>${input}</scope>
+
+**Principles:** YAGNI, KISS, DRY | Preserve functionality | Token efficiency
+
+## Simplification Rules
+
+- Reduce unnecessary nesting — prefer early returns and guard clauses
+- Eliminate redundant code and abstractions
+- Improve variable and function names for clarity
+- Consolidate related logic
+- Remove comments that describe obvious code
+- Choose clarity over brevity — explicit > compact
+- Never combine too many concerns into single functions
+- Never remove helpful abstractions that improve organization
+
+## Process
+
+1. **Identify scope**: Use `${input}` or default to recent `git diff` changes
+2. **Analyze**: Find complexity reduction opportunities
+3. **Apply standards**: Follow `./docs/code-standards.md` conventions
+4. **Refine**: Simplify without changing behavior
+5. **Verify**: Run typecheck + linter to confirm no breakage
+
+## Scope Rules
+
+- **Default**: Only refine recently modified code (git diff)
+- **Explicit path**: Review specified files/directories
+- **Never**: Refactor unrelated code or change architecture
+
+---
+
+## Suggested Next Steps
+
+| Command | Description |
+|---------|-------------|
+| `/ck.test` | Run tests to verify nothing broke |
+| `/ck.review` | Code review the simplified code |
+| `/ck.git` | Commit changes |