cokit-cli 1.2.7 → 1.4.0

package/skills/fix/SKILL.md

@@ -1,112 +0,0 @@
----
-name: fix
-description: ALWAYS activate this skill before fixing ANY bug, error, test failure, CI/CD issue, type error, lint, log error, UI issue, code problem.
----
-
-# Fixing
-
-Unified skill for fixing issues of any complexity with intelligent routing.
-
-## Arguments
-
-- `--auto` - Activate autonomous mode (**default**)
-- `--review` - Activate human-in-the-loop review mode
-- `--quick` - Activate quick mode
-- `--parallel` - Fix 2+ independent issues concurrently using parallel agents
-
-## Workflow
-
-### Step 1: Mode Selection
-
-**First action:** If there is no "auto" keyword in the request, ask the user directly to choose a workflow mode (then wait for response):
-
-| Option | Recommend When | Behavior |
-|--------|----------------|----------|
-| **Autonomous** (default) | Simple/moderate issues | Auto-approve if score >= 9.5 & 0 critical |
-| **Human-in-the-loop Review** | Critical/production code | Pause for approval at each step |
-| **Quick** | Type errors, lint, trivial bugs | Fast debug → fix → review cycle |
-
-See `references/mode-selection.md` for question format.
-
-### Step 2: Debug
-
-- Activate `debug` skill.
-- Guess all possible root causes.
-- Spawn multiple parallel search agents to verify each hypothesis.
-- Create report with all findings for the next step.
-
-### Step 3: Complexity Assessment & Task Orchestration
-
-Classify before routing. See `references/complexity-assessment.md`.
-
-| Level | Indicators | Workflow |
-|-------|------------|----------|
-| **Simple** | Single file, clear error, type/lint | `references/workflow-quick.md` |
-| **Moderate** | Multi-file, root cause unclear | `references/workflow-standard.md` |
-| **Complex** | System-wide, architecture impact | `references/workflow-deep.md` |
-| **Parallel** | 2+ independent issues | Parallel `fullstack-developer` agents |
-
-**Task orchestration notes:**
-- **Quick workflow:** Skip task creation — proceed directly to fix.
-- **Moderate+ workflows:** After classifying, create a todo checklist for all phases upfront with dependencies before starting any implementation. Track each phase with checkboxes and note blockers inline.
-
-See `references/task-orchestration.md` for checklist structure and dependency tracking patterns.
-
-### Step 4: Fix Implementation & Verification
-
-- Read and analyze all the implemented changes.
-- Spawn multiple parallel search agents to verify no regressions in related code.
-- Make sure these fixes don't break other parts of the codebase.
-- Prevent future issues by adding comprehensive validation.
-
-### Step 5: Finalize
-
-**MANDATORY — always execute all steps:**
-
-1. Report summary to user with confidence score (0–10), all changes, and related files.
-2. Update `./docs` via ``docs-manager`` agent (NON-OPTIONAL — always run even for small fixes).
-3. Mark all checklist tasks complete.
-4. Ask user to commit via ``git-manager`` agent.
-
----
-
-## IMPORTANT: Skill/Agent Activation Matrix
-
-See `references/skill-activation-matrix.md` for complete matrix.
-
-**Always activate:** `debug` (all workflows)
-**Conditional:** `problem-solving`, `sequential-thinking`, `brainstorming`, `context-engineering`
-**Agents:** ``debugger``, ``researcher``, ``planner``, ``code-reviewer``, ``tester``
-**Parallel patterns:** Multiple parallel search agents for scouting; parallel terminal commands for verification; parallel ``fullstack-developer`` agents for independent issues (`--parallel` flag)
-
-## Output Format
-
-Unified step markers:
-```
-✓ Step 0: [Mode] selected - [Complexity] detected
-✓ Step 1: Root cause identified - [summary]
-✓ Step 2: Fix implemented - [N] files changed
-✓ Step 3: Tests [X/X passed]
-✓ Step 4: Review [score]/10 - [status]
-✓ Step 5: Complete - [action taken]
-```
-
-## References
-
-Load as needed:
-- `references/mode-selection.md` - Mode selection question format
-- `references/complexity-assessment.md` - Classification criteria
-- `references/task-orchestration.md` - Todo checklist structure and dependency tracking
-- `references/workflow-quick.md` - Quick: debug → fix → review
-- `references/workflow-standard.md` - Standard: full pipeline
-- `references/workflow-deep.md` - Deep: research + brainstorm + plan
-- `references/review-cycle.md` - Review logic (autonomous vs HITL)
-- `references/skill-activation-matrix.md` - When to activate each skill
-- `references/parallel-exploration.md` - Parallel search and execution patterns
-
-**Specialized Workflows:**
-- `references/workflow-ci.md` - GitHub Actions/CI failures
-- `references/workflow-logs.md` - Application log analysis
-- `references/workflow-test.md` - Test suite failures
-- `references/workflow-types.md` - TypeScript type errors
-- `references/workflow-ui.md` - Visual/UI issues (requires design skills)

package/skills/fix/references/complexity-assessment.md

@@ -1,61 +0,0 @@
-# Complexity Assessment
-
-Classify issue complexity before routing to workflow.
-
-## Classification Criteria
-
-### Simple (→ workflow-quick.md)
-
-**Indicators:**
-- Single file affected
-- Clear error message (type error, syntax, lint)
-- Keywords: `type`, `typescript`, `tsc`, `lint`, `eslint`, `syntax`
-- Obvious fix location
-- No investigation needed
-
-**Examples:**
-- "Fix type error in auth.ts"
-- "ESLint errors after upgrade"
-- "Syntax error in config file"
-
-### Moderate (→ workflow-standard.md)
-
-**Indicators:**
-- 2-5 files affected
-- Root cause unclear but localized
-- Needs debugging investigation
-- Keywords: `bug`, `broken`, `not working`, `fails sometimes`
-- Test failures with unclear cause
-
-**Examples:**
-- "Login sometimes fails"
-- "API returns wrong data"
-- "Component not rendering correctly"
-
-### Complex (→ workflow-deep.md)
-
-**Indicators:**
-- System-wide impact (5+ files)
-- Architecture decision needed
-- Research required for solution
-- Keywords: `architecture`, `refactor`, `system-wide`, `design issue`
-- Performance/security vulnerabilities
-- Multiple interacting components
-
-**Examples:**
-- "Memory leak in production"
-- "Database deadlocks under load"
-- "Security vulnerability in auth flow"
-
-### Parallel (→ multiple fullstack-developer agents)
-
-**Indicators:**
-- 2+ independent issues mentioned
-- Issues in different areas (frontend + backend, auth + payments)
-- No dependencies between issues
-- Keywords: list of issues, "and", "also", multiple error types
-
-**Examples:**
-- "Fix type errors AND update UI styling"
-- "Auth bug + payment integration issue"
-- "3 different test failures in unrelated modules"

package/skills/fix/references/mode-selection.md

@@ -1,30 +0,0 @@
-# Mode Selection
-
-Ask the user at start of fixing workflow to choose a mode. Present the question directly in your response, then stop and wait for their answer.
-
-## Question Format
-
-Ask the user:
-
-> **Fix Mode:** How should I handle the fix workflow?
->
-> 1. **Autonomous (Recommended)** — Auto-approve if quality high, only ask when stuck
-> 2. **Human-in-the-loop** — Pause for approval at each major step
-> 3. **Quick fix** — Fast debug-fix-review cycle for simple issues
-
-## Mode Recommendations
-
-| Issue Type | Recommended Mode |
-|------------|------------------|
-| Type errors, lint errors | Quick |
-| Single file bugs | Quick or Autonomous |
-| Multi-file, unclear root cause | Autonomous |
-| Production/critical code | Human-in-the-loop |
-| System-wide/architecture | Human-in-the-loop |
-| Security vulnerabilities | Human-in-the-loop |
-
-## Skip Mode Selection When
-
-- Issue is clearly trivial (type error keyword detected) → default Quick
-- User explicitly specified mode in prompt
-- Previous context already established mode

package/skills/fix/references/parallel-exploration.md

@@ -1,77 +0,0 @@
-# Parallel Exploration
-
-Patterns for launching multiple agents in parallel to scout codebase and verify implementation.
-
-## Parallel Exploration (Scouting)
-
-Launch multiple `Explore` agents simultaneously when needing to find:
-- Related files across different areas
-- Similar implementations/patterns
-- Dependencies and usage
-
-**Pattern:**
-```
-Task(agent_type="Explore", prompt="Find [X] in [area1]", description="Scout area1")
-Task(agent_type="Explore", prompt="Find [Y] in [area2]", description="Scout area2")
-Task(agent_type="Explore", prompt="Find [Z] in [area3]", description="Scout area3")
-```
-
-**Example - Multi-area scouting:**
-```
-// Launch in SINGLE message with multiple Task calls:
-Task("Explore", "Find auth-related files in src/", "Scout auth")
-Task("Explore", "Find API routes handling users", "Scout API")
-Task("Explore", "Find test files for auth module", "Scout tests")
-```
-
-## Parallel Verification (Bash)
-
-Launch multiple `Bash` agents to verify implementation from different angles.
-
-**Pattern:**
-```
-Task(agent_type="Bash", prompt="Run [command1]", description="Verify X")
-Task(agent_type="Bash", prompt="Run [command2]", description="Verify Y")
-```
-
-**Example - Multi-verification:**
-```
-// Launch in SINGLE message:
-Task("Bash", "Run typecheck: bun run typecheck", "Verify types")
-Task("Bash", "Run lint: bun run lint", "Verify lint")
-Task("Bash", "Run build: bun run build", "Verify build")
-```
-
-## When to Use Parallel
-
-| Scenario | Parallel Strategy |
-|----------|-------------------|
-| Root cause unclear, multiple suspects | 2-3 Explore agents on different areas |
-| Multi-module fix | Explore each module in parallel |
-| After implementation | Bash agents for typecheck + lint + build |
-| Before commit | Bash agents for test + build + lint |
-
-## Combining Explore + Bash
-
-**Step 1:** Parallel Explore to scout
-**Step 2:** Sequential implementation
-**Step 3:** Parallel Bash to verify
-
-```
-// Scout phase - parallel
-Task("Explore", "Find payment handlers", "Scout payments")
-Task("Explore", "Find order processors", "Scout orders")
-
-// Wait for results, implement fix
-
-// Verify phase - parallel
-Task("Bash", "Run tests: bun test", "Run tests")
-Task("Bash", "Run typecheck", "Check types")
-Task("Bash", "Run build", "Verify build")
-```
-
-## Resource Limits
-
-- Max 3 parallel agents recommended (system resources)
-- Each agent has 200K token context limit
-- Keep prompts concise to avoid context bloat

package/skills/fix/references/review-cycle.md

@@ -1,77 +0,0 @@
-# Review Cycle
-
-Mode-aware review handling for code-reviewer results.
-
-## Autonomous Mode
-
-```
-cycle = 0
-LOOP:
-  1. Run code-reviewer → score, critical_count, warnings, suggestions
-
-  2. IF score >= 9.5 AND critical_count == 0:
-     → Output: "✓ Review [score]/10 - Auto-approved"
-     → PROCEED to next step
-
-  3. ELSE IF critical_count > 0 AND cycle < 3:
-     → Output: "⚙ Auto-fixing [N] critical issues (cycle [cycle+1]/3)"
-     → Fix critical issues
-     → Re-run tests
-     → cycle++, GOTO LOOP
-
-  4. ELSE IF cycle >= 3:
-     → ESCALATE to user directly in response
-     → Display findings
-     → Ask: "Fix manually" / "Approve anyway" / "Abort" — wait for response
-
-  5. ELSE (score < 9.5, no critical):
-     → Output: "✓ Review [score]/10 - Approved with [N] warnings"
-     → PROCEED (warnings logged, not blocking)
-```
-
-## Human-in-the-Loop Mode
-
-```
-ALWAYS:
-  1. Run code-reviewer → score, critical_count, warnings, suggestions
-
-  2. Display findings:
-     ┌─────────────────────────────────────┐
-     │ Review: [score]/10                  │
-     ├─────────────────────────────────────┤
-     │ Critical ([N]): [list]              │
-     │ Warnings ([N]): [list]              │
-     │ Suggestions ([N]): [list]           │
-     └─────────────────────────────────────┘
-
-  3. Ask user directly in response, then wait for answer:
-     IF critical_count > 0:
-       - "Fix critical issues"
-       - "Fix all issues"
-       - "Approve anyway"
-       - "Abort"
-     ELSE:
-       - "Approve"
-       - "Fix warnings/suggestions"
-       - "Abort"
-
-  4. Handle response:
-     - Fix → implement, re-test, re-review (max 3 cycles)
-     - Approve → proceed
-     - Abort → stop workflow
-```
-
-## Quick Mode Review
-
-Uses same logic as Autonomous but:
-- Lower threshold: score >= 8.5 acceptable
-- Only 1 auto-fix cycle before escalate
-- Focus on: correctness, security, no regressions
-
-## Critical Issues (Always Block)
-
-- Security vulnerabilities (XSS, SQL injection, OWASP)
-- Performance bottlenecks (O(n²) when O(n) possible)
-- Architectural violations
-- Data loss risks
-- Breaking changes without migration

package/skills/fix/references/skill-activation-matrix.md

@@ -1,65 +0,0 @@
-# Skill Activation Matrix
-
-When to activate each skill during fixing workflows.
-
-## Always Activate
-
-| Skill | Reason |
-|-------|--------|
-| `debug` | Core to all fix workflows - find root cause first |
-
-## Conditional Activation
-
-| Skill | Activate When |
-|-------|---------------|
-| `problem-solving` | Stuck on approach, multiple failed attempts |
-| `sequential-thinking` | Complex logic chain, multi-step reasoning needed |
-| `brainstorming` | Multiple valid approaches, architecture decision |
-| `context-engineering` | Fixing AI/LLM/agent code, context window issues |
-| ImageMagick/FFmpeg | Image/video processing, visual asset manipulation |
-
-## Agent Usage
-
-| Agent | Activate When |
-|----------|---------------|
-| `debugger` | Root cause unclear, need deep investigation |
-| `Explore` (parallel) | Scout multiple areas simultaneously |
-| `Bash` (parallel) | Verify implementation (typecheck, lint, build) |
-| `researcher` | External docs needed, latest best practices |
-| `planner` | Complex fix needs breakdown, multiple phases |
-| `tester` | After implementation, verify fix works |
-| `code-reviewer` | After fix, verify quality and security |
-| `git-manager` | After approval, commit changes |
-| `docs-manager` | API/behavior changes need doc updates |
-| `project-manager` | Major fix impacts roadmap/plan status |
-
-## Parallel Patterns
-
-See `references/parallel-exploration.md` for detailed patterns.
-
-| When | Parallel Strategy |
-|------|-------------------|
-| Root cause unclear | 2-3 `Explore` agents on different areas |
-| Multi-module fix | `Explore` each module in parallel |
-| After implementation | `Bash` agents: typecheck + lint + build |
-| Before commit | `Bash` agents: test + build + lint |
-
-## Workflow → Skills Map
-
-| Workflow | Skills Activated |
-|----------|------------------|
-| Quick | `debug`, `code-reviewer`, parallel `Bash` verification |
-| Standard | Above + `problem-solving`, `sequential-thinking`, `tester`, parallel `Explore` |
-| Deep | All above + `brainstorming`, `context-engineering`, `researcher`, `planner` |
-| Parallel | Per-issue workflow + coordination via parallel agents |
-
-## Detection Triggers
-
-| Keyword/Pattern | Skill to Consider |
-|-----------------|-------------------|
-| "AI", "LLM", "agent", "context" | `context-engineering` |
-| "stuck", "tried everything" | `problem-solving` |
-| "complex", "multi-step" | `sequential-thinking` |
-| "which approach", "options" | `brainstorming` |
-| "latest docs", "best practice" | `researcher` agent |
-| Screenshot attached | Visual analysis |

package/skills/fix/references/workflow-ci.md

@@ -1,28 +0,0 @@
-# CI/CD Fix Workflow
-
-For GitHub Actions failures and CI/CD pipeline issues.
-
-## Prerequisites
-- `gh` CLI installed and authorized
-- GitHub Actions URL or run ID
-
-## Workflow
-
-1. **Fetch logs** with `debugger` agent:
-   ```bash
-   gh run view <run-id> --log-failed
-   gh run view <run-id> --log
-   ```
-
-2. **Analyze** root cause from logs
-
-3. **Implement fix** based on analysis
-
-4. **Test locally** with `tester` agent before pushing
-
-5. **Iterate** if tests fail, repeat from step 3
-
-## Notes
-- If `gh` unavailable, instruct user to install: `gh auth login`
-- Check both failed step and preceding steps for context
-- Common issues: env vars, dependencies, permissions, timeouts

package/skills/fix/references/workflow-deep.md

@@ -1,91 +0,0 @@
-# Deep Workflow
-
-Full pipeline with research, brainstorming, and planning for complex issues.
-
-## Steps
-
-### Step 1: Debug & Parallel Investigation
-Activate `debug` skill. Launch 2-3 `Explore` agents in parallel:
-```
-Task("Explore", "Find error origin", "Trace error")
-Task("Explore", "Find affected components", "Map deps")
-Task("Explore", "Find similar patterns", "Find patterns")
-```
-See `references/parallel-exploration.md` for patterns.
-
-**Output:** `✓ Step 1: Root cause - [summary], system impact: [scope]`
-
-### Step 2: Research
-Use `researcher` agent for external knowledge.
-
-- Search latest docs, best practices
-- Find similar issues/solutions
-- Gather security advisories if relevant
-
-**Output:** `✓ Step 2: Research complete - [key findings]`
-
-### Step 3: Brainstorm
-Activate `brainstorming` skill.
-
-- Evaluate multiple approaches
-- Consider trade-offs
-- Get user input on preferred direction
-
-**Output:** `✓ Step 3: Approach selected - [chosen approach]`
-
-### Step 4: Plan
-Use `planner` agent to create implementation plan.
-
-- Break down into phases
-- Identify dependencies
-- Define success criteria
-
-**Output:** `✓ Step 4: Plan created - [N] phases`
-
-### Step 5: Implement
-Implement per plan. Use `context-engineering`, `sequential-thinking`, `problem-solving`.
-
-**Parallel Verification:** Launch `Bash` agents: typecheck + lint + build
-See `references/parallel-exploration.md`
-
-**Output:** `✓ Step 5: Implemented - [N] files, [M] phases, verified`
-
-### Step 6: Test
-Use `tester` agent.
-
-- Comprehensive testing
-- Edge cases, security, performance
-- If fail → debug, fix, repeat
-
-**Output:** `✓ Step 6: Tests [X/X passed]`
-
-### Step 7: Review
-Use `code-reviewer` agent.
-
-See `references/review-cycle.md` for mode-specific handling.
-
-**Output:** `✓ Step 7: Review [score]/10 - [status]`
-
-### Step 8: Finalize
-- Use `project-manager` agent to update roadmap
-- Use `docs-manager` agent for documentation
-- Use `git-manager` agent for commit
-
-**Output:** `✓ Step 8: Complete - [actions taken]`
-
-## Skills/Agents Activated
-
-| Step | Skills/Agents |
-|------|------------------|
-| 1 | `debug`, parallel `Explore` agents for investigation |
-| 2 | `researcher` |
-| 3 | `brainstorm` |
-| 4 | `planner` |
-| 5 | `problem-solving`, `sequential-thinking`, `context-engineering`, parallel `Bash` |
-| 6 | `tester` |
-| 7 | `code-reviewer` |
-| 8 | `project-manager`, `docs-manager`, `Bash` |
-
-**Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
-**Frontend:** Use `agent-browser` or browser automation tools to verify.
-**Visual Assets:** Use ImageMagick/FFmpeg CLI for image/video processing.

package/skills/fix/references/workflow-logs.md

@@ -1,36 +0,0 @@
-# Log Analysis Fix Workflow
-
-For fixing issues from application logs.
-
-## Prerequisites
-- Log file at `./logs.txt` or similar
-
-## Setup (if logs missing)
-
-Add permanent log piping to project config:
-- **Bash/Unix**: `command 2>&1 | tee logs.txt`
-- **PowerShell**: `command *>&1 | Tee-Object logs.txt`
-
-## Workflow
-
-1. **Read logs** with `Grep` (use `head_limit: 30` initially)
-   - Increase limit if insufficient context
-
-2. **Analyze** with `debugger` agent for root causes
-
-3. **Scout** codebase with `scout` agent for issue locations
-
-4. **Plan** fix with `planner` agent
-
-5. **Implement** the fix
-
-6. **Test** with `tester` agent
-
-7. **Review** with `code-reviewer` agent
-
-8. **Iterate** if issues remain, repeat from step 3
-
-## Tips
-- Focus on last N lines first (most recent errors)
-- Look for stack traces, error codes, timestamps
-- Check for patterns/repeated errors

package/skills/fix/references/workflow-quick.md

@@ -1,59 +0,0 @@
-# Quick Workflow
-
-Fast debug-fix-review cycle for simple issues.
-
-## Steps
-
-### Step 1: Debug
-Activate `debug` skill. Find root cause quickly. Verify the root cause with multiple `Explore` agents in parallel.
-- Read error message/logs
-- Locate affected file(s)
-- Identify exact fix needed
-
-**Output:** `✓ Step 1: Root cause - [brief description]`
-
-### Step 2: Fix & Verify
-Implement the fix directly.
-- Make minimal changes
-- Follow existing patterns
-
-**Parallel Verification:**
-Launch `Bash` agents in parallel:
-```
-Task("Bash", "Run typecheck", "Verify types")
-Task("Bash", "Run lint", "Verify lint")
-```
-
-See `references/parallel-exploration.md` for patterns.
-
-**Output:** `✓ Step 2: Fixed - [N] files, verified (types/lint passed)`
-
-### Step 3: Verify
-Use `code-reviewer` agent for quick review.
-
-Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regressions. Score X/10."
-
-**Review handling:** See `references/review-cycle.md`
-
-**Output:** `✓ Step 3: Review [score]/10 - [status]`
-
-### Step 4: Complete
-Report summary to user.
-
-**If autonomous mode:** Ask to commit via `git-manager` agent if score >= 9.0
-**If HITL mode:** Ask user next action
-
-**Output:** `✓ Step 4: Complete - [action]`
-
-## Skills/Agents Activated
-
-- `debug` - Always (Step 1)
-- Parallel `git-manager` - Verification (Step 2)
-- `code-reviewer` agent - Always (Step 3)
-- `context-engineering` - If dealing with AI/LLM code
-
-## Notes
-
-- Skip if review fails → escalate to Standard workflow
-- Total steps: 4 (vs 5-6 in Standard/Deep)
-- No planning phase needed