cokit-cli 1.2.7 → 1.4.0

package/skills/scout/SKILL.md

@@ -1,91 +0,0 @@
----
-name: scout
-description: Fast codebase scouting using parallel agents. Use for file discovery, task context gathering, quick searches across directories. Supports internal and external search agents.
----
-
-# Scout
-
-Fast, token-efficient codebase scouting using parallel agents to find files needed for tasks.
-
-## Arguments
-- Default: Scout using built-in search agents in parallel (`./references/internal-scouting.md`)
-- `ext`: Scout using external Gemini/OpenCode CLI tools in parallel (`./references/external-scouting.md`)
-
-## 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
-
-## Quick Start
-
-1. Analyze user prompt to identify search targets
-2. Use a wide range of Grep and Glob patterns to find relevant files and estimate scale of the codebase
-3. Spawn parallel agents with divided directories
-4. Collect results into concise report
-
-## Configuration
-
-Read from `$HOME/.copilot/.ck.json`:
-- `gemini.model` - Gemini model (default: `gemini-3-flash-preview`)
-
-## Workflow
-
-### 1. Analyze Task
-- Parse user prompt for search targets
-- Identify key directories, patterns, file types, lines of code
-- Determine optimal SCALE value of agents to spawn
-
-### 2. Divide and Conquer
-- Split codebase into logical segments per agent
-- Assign each agent specific directories or patterns
-- Ensure no overlap, maximize coverage
-
-### 3. Register Scout Tasks
-
-**Skip this step if agent count <= 2.**
-
-- Check for existing scout tasks in the current session to avoid duplicates.
-- Create a markdown checklist — one entry per agent — including scope metadata (directories, patterns assigned).
-- Example checklist entry: `- [ ] Agent 1: src/api/*, src/models/* — searching for auth-related files`
-- Reference: `references/task-management-scouting.md` for checklist format and metadata fields.
-
-### 4. Spawn Parallel Agents
-
-Load appropriate reference based on decision tree:
-- **Internal (Default):** `references/internal-scouting.md` (search agents)
-- **External:** `references/external-scouting.md` (Gemini/OpenCode)
-
-**Notes:**
-- Update each task to in_progress before spawning its agent.
-- Prompt detailed instructions for each agent with exact directories or files it should read.
-- Remember that each agent has less than 200K tokens of context window.
-- Amount of agents to-be-spawned depends on the current system resources available and amount of files to be scanned.
-- Each agent must return a detailed summary report to a main agent.
-
-### 5. Collect Results
-- Timeout: 3 minutes per agent (skip non-responders).
-- Update completed tasks to done; log timed-out agents in the report under "Unresolved Questions".
-- Aggregate findings into single report.
-- List unresolved questions at end.
-
-## Report Format
-
-```markdown
-# Scout Report
-
-## Relevant Files
-- `path/to/file.ts` - Brief description
-- ...
-
-## Unresolved Questions
-- Any gaps in findings
-```
-
-## References
-
-- `references/internal-scouting.md` - Using search agents
-- `references/external-scouting.md` - Using Gemini/OpenCode CLI
-- `references/task-management-scouting.md` - Checklist format and scope metadata for scout tasks

package/skills/scout/references/external-scouting.md

@@ -1,140 +0,0 @@
-# External Scouting with Gemini/OpenCode
-
-Use external agentic tools for faster searches with large context windows (1M+ tokens).
-
-## Tool Selection
-
-```
-SCALE <= 3  → gemini CLI
-SCALE 4-5   → opencode CLI
-SCALE >= 6  → Use internal scouting instead
-```
-
-## Configuration
-
-Read from `$HOME/.copilot/.ck.json`:
-```json
-{
-  "gemini": {
-    "model": "gemini-3.0-flash"
-  }
-}
-```
-
-Default model: `gemini-3.0-flash`
-
-## Gemini CLI (SCALE <= 3)
-
-### Command
-```bash
-gemini -y -m <model> "[prompt]"
-```
-
-### Example
-```bash
-gemini -y -m gemini-3.0-flash "Search src/ for authentication files. List paths with brief descriptions."
-```
-
-## OpenCode CLI (SCALE 4-5)
-
-### Command
-```bash
-opencode run "[prompt]" --model opencode/grok-code
-```
-
-### Example
-```bash
-opencode run "Find all payment-related files in lib/ and api/" --model opencode/grok-code
-```
-
-## Installation Check
-
-Before using, verify tools installed:
-```bash
-which gemini
-which opencode
-```
-
-If not installed, ask user:
-1. **Yes** - Provide installation instructions (may need manual auth steps)
-2. **No** - Fall back to Explore agents (`internal-scouting.md`)
-
-## Spawning Parallel Bash Agents
-
-Use `Task` tool with `type: "Bash"` to spawn parallel agents:
-
-```
-Task 1: type="Bash", prompt="Run: gemini -y -m gemini-3.0-flash '[prompt1]'"
-Task 2: type="Bash", prompt="Run: gemini -y -m gemini-3.0-flash '[prompt2]'"
-Task 3: type="Bash", prompt="Run: gemini -y -m gemini-3.0-flash '[prompt3]'"
-```
-
-Spawn all in single message for parallel execution.
-
-## Prompt Guidelines
-
-- Be specific about directories to search
-- Request file paths with descriptions
-- Set clear scope boundaries
-- Ask for patterns/relationships if relevant
-
-## Example Workflow
-
-User: "Find database migration files"
-
-Spawn 3 parallel Bash agents via Task tool:
-```
-Task 1 (Bash): "Run: gemini -y -m gemini-3.0-flash 'Search db/, migrations/ for migration files'"
-Task 2 (Bash): "Run: gemini -y -m gemini-3.0-flash 'Search lib/, src/ for database schema files'"
-Task 3 (Bash): "Run: gemini -y -m gemini-3.0-flash 'Search config/ for database configuration'"
-```
-
-## Reading File Content
-
-When needing to read file content, use chunking to stay within context limits (<150K tokens safe zone).
-
-### Step 1: Get Line Counts
-```bash
-wc -l path/to/file1.ts path/to/file2.ts path/to/file3.ts
-```
-
-### Step 2: Calculate Chunks
-- **Target:** ~500 lines per chunk (safe for most files)
-- **Max files per agent:** 3-5 small files OR 1 large file chunked
-
-**Chunking formula:**
-```
-chunks = ceil(total_lines / 500)
-lines_per_chunk = ceil(total_lines / chunks)
-```
-
-### Step 3: Spawn Parallel Bash Agents
-
-**Small files (<500 lines each):**
-```
-Task 1: type="Bash", prompt="cat file1.ts file2.ts"
-Task 2: type="Bash", prompt="cat file3.ts file4.ts"
-```
-
-**Large file (>500 lines) - use sed for ranges:**
-```
-Task 1: type="Bash", prompt="sed -n '1,500p' large-file.ts"
-Task 2: type="Bash", prompt="sed -n '501,1000p' large-file.ts"
-Task 3: type="Bash", prompt="sed -n '1001,1500p' large-file.ts"
-```
-
-### Chunking Decision Tree
-```
-File < 500 lines     → Read entire file
-File 500-1500 lines  → Split into 2-3 chunks
-File > 1500 lines    → Split into ceil(lines/500) chunks
-```
-
-Spawn all in single message for parallel execution.
-
-## Timeout and Error Handling
-
-- Set 3-minute timeout per bash call
-- Skip timed-out agents
-- Don't restart failed agents
-- On persistent failures, fall back to internal scouting

package/skills/scout/references/internal-scouting.md

@@ -1,119 +0,0 @@
-# Internal Scouting with Explore Agents
-
-Use Explore agents when SCALE >= 6 or external tools unavailable.
-
-## How It Works
-
-Spawn multiple `Explore` agents via `Task` tool to search codebase in parallel.
-
-## Task Tool Configuration
-
-```
-type: "Explore"
-```
-
-## Prompt Template
-
-```
-Quickly scout {DIRECTORY} for files related to: {USER_PROMPT}
-
-Instructions:
-- Search for relevant files matching the task
-- Use Glob/Grep for file discovery
-- List files with brief descriptions
-- Timeout: 3 minutes max
-- Skip if timeout reached
-
-Report format:
-## Found Files
-- `path/file.ext` - description
-
-## Patterns
-- Key patterns observed
-```
-
-## Spawning Strategy
-
-### Directory Division
-Split codebase logically:
-- `src/` - Source code
-- `lib/` - Libraries
-- `tests/` - Test files
-- `config/` - Configuration
-- `api/` - API routes
-
-### Parallel Execution
-- Spawn all agents in single `Task` tool call
-- Each agent gets distinct directory scope
-- No overlap between agents
-
-## Example
-
-User prompt: "Find authentication-related files"
-
-```
-Agent 1: Scout src/auth/, src/middleware/ for auth files
-Agent 2: Scout src/api/, src/routes/ for auth endpoints
-Agent 3: Scout tests/ for auth tests
-Agent 4: Scout lib/, utils/ for auth utilities
-Agent 5: Scout config/ for auth configuration
-Agent 6: Scout types/, interfaces/ for auth types
-```
-
-## Timeout Handling
-
-- Set 3-minute timeout per agent
-- Skip non-responding agents
-- Don't restart timed-out agents
-- Aggregate available results
-
-## Reading File Content
-
-When needing to read file content, use chunking to stay within context limits (<150K tokens safe zone).
-
-### Step 1: Get Line Counts
-```bash
-wc -l path/to/file1.ts path/to/file2.ts path/to/file3.ts
-```
-
-### Step 2: Calculate Chunks
-- **Target:** ~500 lines per chunk (safe for most files)
-- **Max files per agent:** 3-5 small files OR 1 large file chunked
-
-**Chunking formula:**
-```
-chunks = ceil(total_lines / 500)
-lines_per_chunk = ceil(total_lines / chunks)
-```
-
-### Step 3: Spawn Parallel Bash Agents
-
-**Small files (<500 lines each):**
-```
-Task 1: type="Bash", prompt="cat file1.ts file2.ts"
-Task 2: type="Bash", prompt="cat file3.ts file4.ts"
-```
-
-**Large file (>500 lines) - use sed for ranges:**
-```
-Task 1: type="Bash", prompt="sed -n '1,500p' large-file.ts"
-Task 2: type="Bash", prompt="sed -n '501,1000p' large-file.ts"
-Task 3: type="Bash", prompt="sed -n '1001,1500p' large-file.ts"
-```
-
-### Chunking Decision Tree
-```
-File < 500 lines     → Read entire file
-File 500-1500 lines  → Split into 2-3 chunks
-File > 1500 lines    → Split into ceil(lines/500) chunks
-```
-
-Spawn all in single message for parallel execution.
-
-## Result Aggregation
-
-Combine results from all agents:
-1. Deduplicate file paths
-2. Merge descriptions
-3. Note any gaps/timeouts
-4. List unresolved questions

package/skills/sequential-thinking/README.md

@@ -1,183 +0,0 @@
-# Sequential Thinking Agent Skill
-
-Structured, reflective problem-solving methodology converted from the sequential-thinking MCP server into a native Agent Skill.
-
-## Overview
-
-This skill teaches the AI agent to apply systematic sequential thinking methodology for complex problem-solving, without relying on external MCP tools. It enables:
-- Breaking down complex problems into manageable thought sequences
-- Dynamic adjustment of thought count as understanding evolves
-- Revision of previous thoughts when new insights emerge
-- Branching into alternative reasoning paths
-- Hypothesis generation and verification
-
-## Skill Structure
-
-```
-sequential-thinking/
-├── SKILL.md (105 lines)
-│   Core methodology, when to apply, scripts usage
-│
-├── package.json
-│   Test dependencies (jest)
-│
-├── .env.example
-│   Configuration options
-│
-├── scripts/
-│   ├── process-thought.js (executable)
-│   │   Validate and track thoughts deterministically
-│   │
-│   └── format-thought.js (executable)
-│       Format thoughts for display (box/simple/markdown)
-│
-├── tests/
-│   ├── process-thought.test.js
-│   │   Validation, tracking, history tests
-│   │
-│   └── format-thought.test.js
-│       Formatting tests (all formats)
-│
-└── references/
-    ├── core-patterns.md (95 lines)
-    │   Essential revision & branching patterns
-    │
-    ├── examples-api.md (88 lines)
-    │   API design example walkthrough
-    │
-    ├── examples-debug.md (90 lines)
-    │   Performance debugging example
-    │
-    ├── examples-architecture.md (94 lines)
-    │   Architecture decision example
-    │
-    ├── advanced-techniques.md (76 lines)
-    │   Spiral refinement, hypothesis testing, convergence
-    │
-    └── advanced-strategies.md (79 lines)
-        Uncertainty management, revision cascades, meta-thinking
-```
-
-**Documentation**: 627 lines across 7 files (all under 100 lines)
-**Scripts**: 2 executable Node.js scripts with tests
-
-## Key Features
-
-### Progressive Disclosure Design
-Each file focuses on specific aspects, loaded only when needed:
-- **SKILL.md**: Quick reference with core methodology
-- **core-patterns.md**: Common patterns for everyday use
-- **examples-*.md**: Real-world walkthroughs for learning
-- **advanced-*.md**: Sophisticated techniques for complex scenarios
-
-### Token Efficiency
-- Concise explanations sacrifice grammar for brevity
-- Examples demonstrate patterns without verbose explanation
-- Cross-references between files avoid duplication
-
-### Methodology Conversion
-Extracted from MCP server's approach and converted to instructions:
-- MCP tool provided **interface** for sequential thinking
-- Agent skill provides **methodology** to think sequentially
-- No dependency on external tools—pure instructional approach
-
-## Usage Modes
-
-**Explicit Mode**: Use visible thought markers
-```
-Thought 1/5: [Analysis]
-Thought 2/5: [Further analysis]
-```
-
-**Implicit Mode**: Apply methodology internally without cluttering output
-
-## When the Agent Should Use This Skill
-
-Automatically activated for:
-- Complex problem decomposition
-- Adaptive planning with potential revisions
-- Debugging and root cause analysis
-- Architecture and design decisions
-- Problems with unclear or emerging scope
-- Multi-step solutions requiring context
-
-## Scripts Usage
-
-### Process Thought (Validation & Tracking)
-
-```bash
-# Process a thought
-node scripts/process-thought.js --thought "Initial analysis" --number 1 --total 5 --next true
-
-# Process with revision
-node scripts/process-thought.js --thought "Corrected analysis" --number 2 --total 5 --next true --revision 1
-
-# Process with branching
-node scripts/process-thought.js --thought "Branch A" --number 2 --total 5 --next true --branch 1 --branchId "branch-a"
-
-# View history
-node scripts/process-thought.js --history
-
-# Reset history
-node scripts/process-thought.js --reset
-```
-
-### Format Thought (Display)
-
-```bash
-# Box format (default)
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5
-
-# Simple text format
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format simple
-
-# Markdown format
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format markdown
-
-# With revision
-node scripts/format-thought.js --thought "Revised" --number 2 --total 5 --revision 1
-
-# With branch
-node scripts/format-thought.js --thought "Branch" --number 2 --total 5 --branch 1 --branchId "a"
-```
-
-### Running Tests
-
-```bash
-# Install dependencies (first time only)
-npm install
-
-# Run all tests
-npm test
-
-# Run tests in watch mode
-npm run test:watch
-
-# Run with coverage
-npm run test:coverage
-```
-
-## When to Use Scripts
-
-**Use scripts when**:
-- Need deterministic validation of thought structure
-- Want persistent thought history tracking
-- Require formatted output for documentation
-- Building tools that integrate with sequential thinking
-
-**Don't use scripts when**:
-- Applying methodology directly in responses
-- Want lightweight, inline thinking
-- No need for validation or tracking
-
-Scripts are **optional tooling** - the methodology can be applied without them.
-
-## Source
-
-Converted from: https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking
-
-Original MCP server (MIT License).
-Skill conversion:
-- Extracts methodology as instructions
-- Adds executable scripts for deterministic validation
-- Makes tool-independent while preserving functionality

package/skills/sequential-thinking/SKILL.md

@@ -1,92 +0,0 @@
----
-name: sequential-thinking
-description: Apply step-by-step analysis for complex problems with revision capability. Use for multi-step reasoning, hypothesis verification, adaptive planning, problem decomposition, course correction.
----
-
-# Sequential Thinking
-
-Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.
-
-## When to Apply
-
-- Complex problem decomposition
-- Adaptive planning with revision capability
-- Analysis needing course correction
-- Problems with unclear/emerging scope
-- Multi-step solutions requiring context maintenance
-- Hypothesis-driven investigation/debugging
-
-## Core Process
-
-### 1. Start with Loose Estimate
-```
-Thought 1/5: [Initial analysis]
-```
-Adjust dynamically as understanding evolves.
-
-### 2. Structure Each Thought
-- Build on previous context explicitly
-- Address one aspect per thought
-- State assumptions, uncertainties, realizations
-- Signal what next thought should address
-
-### 3. Apply Dynamic Adjustment
-- **Expand**: More complexity discovered → increase total
-- **Contract**: Simpler than expected → decrease total
-- **Revise**: New insight invalidates previous → mark revision
-- **Branch**: Multiple approaches → explore alternatives
-
-### 4. Use Revision When Needed
-```
-Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
-- Original: [What was stated]
-- Why revised: [New insight]
-- Impact: [What changes]
-```
-
-### 5. Branch for Alternatives
-```
-Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
-Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
-```
-Compare explicitly, converge with decision rationale.
-
-### 6. Generate & Verify Hypotheses
-```
-Thought 6/9 [HYPOTHESIS]: [Proposed solution]
-Thought 7/9 [VERIFICATION]: [Test results]
-```
-Iterate until hypothesis verified.
-
-### 7. Complete Only When Ready
-Mark final: `Thought N/N [FINAL]`
-
-Complete when:
-- Solution verified
-- All critical aspects addressed
-- Confidence achieved
-- No outstanding uncertainties
-
-## Application Modes
-
-**Explicit**: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown.
-
-**Implicit**: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.
-
-## Scripts (Optional)
-
-Optional scripts for deterministic validation/tracking:
-- `scripts/process-thought.js` - Validate & track thoughts with history
-- `scripts/format-thought.js` - Format for display (box/markdown/simple)
-
-See README.md for usage examples. Use when validation/persistence needed; otherwise apply methodology directly.
-
-## References
-
-Load when deeper understanding needed:
-- `references/core-patterns.md` - Revision & branching patterns
-- `references/examples-api.md` - API design example
-- `references/examples-debug.md` - Debugging example
-- `references/examples-architecture.md` - Architecture decision example
-- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence
-- `references/advanced-strategies.md` - Uncertainty, revision cascades, meta-thinking

package/skills/sequential-thinking/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "sequential-thinking-skill",
-  "version": "1.0.0",
-  "description": "Sequential thinking methodology with thought processing scripts",
-  "main": "scripts/process-thought.js",
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
-  },
-  "keywords": [
-    "sequential-thinking",
-    "problem-solving",
-    "agent-skill"
-  ],
-  "author": "Converted from MCP Server",
-  "license": "MIT",
-  "devDependencies": {
-    "jest": "^29.7.0"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "testMatch": [
-      "**/tests/**/*.test.js"
-    ],
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "/tests/"
-    ]
-  }
-}