cokit-cli 1.0.9 → 1.2.0

package/skills/{ck-planning → planning}/references/research-phase.md

@@ -1,49 +1,49 @@
-# Research & Analysis Phase
-
-**When to skip:** If provided with researcher reports, skip this phase.
-
-## Core Activities
-
-### Parallel Researcher Agents
-- Spawn multiple `researcher` agents in parallel to investigate different approaches
-- Wait for all researcher agents to report back before proceeding
-- Each researcher investigates a specific aspect or approach
-
-### Sequential Thinking
-- Use `sequential-thinking` skill for dynamic and reflective problem-solving
-- Structured thinking process for complex analysis
-- Enables multi-step reasoning with revision capability
-
-### Documentation Research
-- Use `docs-seeker` skill to read and understand documentation
-- Research plugins, packages, and frameworks
-- Find latest technical documentation using llms.txt standard
-
-### GitHub Analysis
-- Use `gh` command to read and analyze:
-  - GitHub Actions logs
-  - Pull requests
-  - Issues and discussions
-- Extract relevant technical context from GitHub resources
-
-### Remote Repository Analysis
-When given GitHub repository URL, generate fresh codebase summary:
-```bash
-# usage: 
-repomix --remote <github-repo-url>
-# example: 
-repomix --remote https://github.com/mrgoonie/human-mcp
-```
-
-### Debugger Delegation
-- Delegate to `debugger` agent for root cause analysis
-- Use when investigating complex issues or bugs
-- Debugger agent specializes in diagnostic tasks
-
-## Best Practices
-
-- Research breadth before depth
-- Document findings for synthesis phase
-- Identify multiple approaches for comparison
-- Consider edge cases during research
-- Note security implications early
+# Research & Analysis Phase
+
+**When to skip:** If provided with researcher reports, skip this phase.
+
+## Core Activities
+
+### Parallel Researcher Agents
+- Spawn multiple `researcher` agents in parallel to investigate different approaches
+- Wait for all researcher agents to report back before proceeding
+- Each researcher investigates a specific aspect or approach
+
+### Sequential Thinking
+- Use `sequential-thinking` skill for dynamic and reflective problem-solving
+- Structured thinking process for complex analysis
+- Enables multi-step reasoning with revision capability
+
+### Documentation Research
+- Use `docs-seeker` skill to read and understand documentation
+- Research plugins, packages, and frameworks
+- Find latest technical documentation using llms.txt standard
+
+### GitHub Analysis
+- Use `gh` command to read and analyze:
+  - GitHub Actions logs
+  - Pull requests
+  - Issues and discussions
+- Extract relevant technical context from GitHub resources
+
+### Remote Repository Analysis
+When given GitHub repository URL, generate fresh codebase summary:
+```bash
+# usage: 
+repomix --remote <github-repo-url>
+# example: 
+repomix --remote https://github.com/mrgoonie/human-mcp
+```
+
+### Debugger Delegation
+- Delegate to `debugger` agent for root cause analysis
+- Use when investigating complex issues or bugs
+- Debugger agent specializes in diagnostic tasks
+
+## Best Practices
+
+- Research breadth before depth
+- Document findings for synthesis phase
+- Identify multiple approaches for comparison
+- Consider edge cases during research
+- Note security implications early

package/{templates/repo/.github/skills/ck-planning → skills/planning}/references/solution-design.md

@@ -1,63 +1,63 @@
-# Solution Design
-
-## Core Principles
-
-Follow these fundamental principles:
-- **YAGNI** (You Aren't Gonna Need It) - Don't add functionality until necessary
-- **KISS** (Keep It Simple, Stupid) - Prefer simple solutions over complex ones
-- **DRY** (Don't Repeat Yourself) - Avoid code duplication
-
-## Design Activities
-
-### Technical Trade-off Analysis
-- Evaluate multiple approaches for each requirement
-- Compare pros and cons of different solutions
-- Consider short-term vs long-term implications
-- Balance complexity with maintainability
-- Assess development effort vs benefit
-- Recommend optimal solution based on current best practices
-
-### Security Assessment
-- Identify potential vulnerabilities during design phase
-- Consider authentication and authorization requirements
-- Assess data protection needs
-- Evaluate input validation requirements
-- Plan for secure configuration management
-- Address OWASP Top 10 concerns
-- Consider API security (rate limiting, CORS, etc.)
-
-### Performance & Scalability
-- Identify potential bottlenecks early
-- Consider database query optimization needs
-- Plan for caching strategies
-- Assess resource usage (memory, CPU, network)
-- Design for horizontal/vertical scaling
-- Plan for load distribution
-- Consider asynchronous processing where appropriate
-
-### Edge Cases & Failure Modes
-- Think through error scenarios
-- Plan for network failures
-- Consider partial failure handling
-- Design retry and fallback mechanisms
-- Plan for data consistency
-- Consider race conditions
-- Design for graceful degradation
-
-### Architecture Design
-- Create scalable system architectures
-- Design for maintainability
-- Plan component interactions
-- Design data flow
-- Consider microservices vs monolith trade-offs
-- Plan API contracts
-- Design state management
-
-## Best Practices
-
-- Document design decisions and rationale
-- Consider both technical and business requirements
-- Think through the entire user journey
-- Plan for monitoring and observability
-- Design with testing in mind
-- Consider deployment and rollback strategies
+# Solution Design
+
+## Core Principles
+
+Follow these fundamental principles:
+- **YAGNI** (You Aren't Gonna Need It) - Don't add functionality until necessary
+- **KISS** (Keep It Simple, Stupid) - Prefer simple solutions over complex ones
+- **DRY** (Don't Repeat Yourself) - Avoid code duplication
+
+## Design Activities
+
+### Technical Trade-off Analysis
+- Evaluate multiple approaches for each requirement
+- Compare pros and cons of different solutions
+- Consider short-term vs long-term implications
+- Balance complexity with maintainability
+- Assess development effort vs benefit
+- Recommend optimal solution based on current best practices
+
+### Security Assessment
+- Identify potential vulnerabilities during design phase
+- Consider authentication and authorization requirements
+- Assess data protection needs
+- Evaluate input validation requirements
+- Plan for secure configuration management
+- Address OWASP Top 10 concerns
+- Consider API security (rate limiting, CORS, etc.)
+
+### Performance & Scalability
+- Identify potential bottlenecks early
+- Consider database query optimization needs
+- Plan for caching strategies
+- Assess resource usage (memory, CPU, network)
+- Design for horizontal/vertical scaling
+- Plan for load distribution
+- Consider asynchronous processing where appropriate
+
+### Edge Cases & Failure Modes
+- Think through error scenarios
+- Plan for network failures
+- Consider partial failure handling
+- Design retry and fallback mechanisms
+- Plan for data consistency
+- Consider race conditions
+- Design for graceful degradation
+
+### Architecture Design
+- Create scalable system architectures
+- Design for maintainability
+- Plan component interactions
+- Design data flow
+- Consider microservices vs monolith trade-offs
+- Plan API contracts
+- Design state management
+
+## Best Practices
+
+- Document design decisions and rationale
+- Consider both technical and business requirements
+- Think through the entire user journey
+- Plan for monitoring and observability
+- Design with testing in mind
+- Consider deployment and rollback strategies

package/skills/{ck-problem-solving → problem-solving}/SKILL.md

@@ -1,95 +1,96 @@
----
-name: 'ck-problem-solving'
-description: 'Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.'
----
-
-# Problem-Solving Techniques
-
-Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.
-
-## When to Use
-
-Apply when encountering:
-- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
-- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
-- **Recurring patterns** - Same issue across domains, reinventing solutions
-- **Assumption constraints** - Forced into "only way", can't question premise
-- **Scale uncertainty** - Production readiness unclear, edge cases unknown
-- **General stuck-ness** - Unsure which technique applies
-
-## Quick Dispatch
-
-**Match symptom to technique:**
-
-| Stuck Symptom | Technique | Reference |
-|---------------|-----------|-----------|
-| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
-| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
-| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
-| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
-| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
-| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |
-
-## Core Techniques
-
-### 1. Simplification Cascades
-Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
-
-**Key insight:** Everything is a special case of one general pattern.
-
-**Red flag:** "Just need to add one more case..." (repeating forever)
-
-### 2. Collision-Zone Thinking
-Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
-
-**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.
-
-**Red flag:** "I've tried everything in this domain"
-
-### 3. Meta-Pattern Recognition
-Spot patterns appearing in 3+ domains to find universal principles.
-
-**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.
-
-**Red flag:** "This problem is unique" (probably not)
-
-### 4. Inversion Exercise
-Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"
-
-**Key insight:** Valid inversions reveal context-dependence of "rules."
-
-**Red flag:** "There's only one way to do this"
-
-### 5. Scale Game
-Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.
-
-**Key insight:** What works at one scale fails at another.
-
-**Red flag:** "Should scale fine" (without testing)
-
-## Application Process
-
-1. **Identify stuck-type** - Match symptom to technique above
-2. **Load detailed reference** - Read specific technique from `references/`
-3. **Apply systematically** - Follow technique's process
-4. **Document insights** - Record what worked/failed
-5. **Combine if needed** - Some problems need multiple techniques
-
-## Combining Techniques
-
-Powerful combinations:
-- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
-- **Collision + Inversion** - Force metaphor, then invert its assumptions
-- **Scale + Simplification** - Extremes reveal what to eliminate
-- **Meta-pattern + Scale** - Universal patterns tested at extremes
-
-## References
-
-Load detailed guides as needed:
-- `references/when-stuck.md` - Dispatch flowchart and decision tree
-- `references/simplification-cascades.md` - Cascade detection and extraction
-- `references/collision-zone-thinking.md` - Metaphor collision process
-- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
-- `references/inversion-exercise.md` - Assumption flipping methodology
-- `references/scale-game.md` - Extreme testing procedures
-- `references/attribution.md` - Source and adaptation notes
+---
+name: Problem-Solving Techniques
+description: Apply systematic problem-solving techniques when stuck. Use for complexity spirals, innovation blocks, recurring patterns, assumption constraints, simplification cascades, scale uncertainty.
+version: 2.0.0
+---
+
+# Problem-Solving Techniques
+
+Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.
+
+## When to Use
+
+Apply when encountering:
+- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
+- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
+- **Recurring patterns** - Same issue across domains, reinventing solutions
+- **Assumption constraints** - Forced into "only way", can't question premise
+- **Scale uncertainty** - Production readiness unclear, edge cases unknown
+- **General stuck-ness** - Unsure which technique applies
+
+## Quick Dispatch
+
+**Match symptom to technique:**
+
+| Stuck Symptom | Technique | Reference |
+|---------------|-----------|-----------|
+| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
+| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
+| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
+| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
+| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
+| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |
+
+## Core Techniques
+
+### 1. Simplification Cascades
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+**Key insight:** Everything is a special case of one general pattern.
+
+**Red flag:** "Just need to add one more case..." (repeating forever)
+
+### 2. Collision-Zone Thinking
+Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"
+
+**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.
+
+**Red flag:** "I've tried everything in this domain"
+
+### 3. Meta-Pattern Recognition
+Spot patterns appearing in 3+ domains to find universal principles.
+
+**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.
+
+**Red flag:** "This problem is unique" (probably not)
+
+### 4. Inversion Exercise
+Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"
+
+**Key insight:** Valid inversions reveal context-dependence of "rules."
+
+**Red flag:** "There's only one way to do this"
+
+### 5. Scale Game
+Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.
+
+**Key insight:** What works at one scale fails at another.
+
+**Red flag:** "Should scale fine" (without testing)
+
+## Application Process
+
+1. **Identify stuck-type** - Match symptom to technique above
+2. **Load detailed reference** - Read specific technique from `references/`
+3. **Apply systematically** - Follow technique's process
+4. **Document insights** - Record what worked/failed
+5. **Combine if needed** - Some problems need multiple techniques
+
+## Combining Techniques
+
+Powerful combinations:
+- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
+- **Collision + Inversion** - Force metaphor, then invert its assumptions
+- **Scale + Simplification** - Extremes reveal what to eliminate
+- **Meta-pattern + Scale** - Universal patterns tested at extremes
+
+## References
+
+Load detailed guides as needed:
+- `references/when-stuck.md` - Dispatch flowchart and decision tree
+- `references/simplification-cascades.md` - Cascade detection and extraction
+- `references/collision-zone-thinking.md` - Metaphor collision process
+- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
+- `references/inversion-exercise.md` - Assumption flipping methodology
+- `references/scale-game.md` - Extreme testing procedures
+- `references/attribution.md` - Source and adaptation notes

package/{templates/repo/.github/skills/ck-problem-solving → skills/problem-solving}/references/attribution.md

@@ -1,69 +1,69 @@
-# Problem-Solving Skills - Attribution
-
-These skills were derived from agent patterns in the Microsoft Amplifier project.
-
-## Source Repository
-
-- **Name:** Amplifier
-- **URL:** https://github.com/microsoft/amplifier
-- **Commit:** 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
-- **Date:** 2025-10-10
-
-## Skills Derived from Amplifier Agents
-
-### From insight-synthesizer agent:
-- **simplification-cascades** - Finding insights that eliminate multiple components
-- **collision-zone-thinking** - Forcing unrelated concepts together for breakthroughs
-- **meta-pattern-recognition** - Spotting patterns across 3+ domains
-- **inversion-exercise** - Flipping assumptions to reveal alternatives
-- **scale-game** - Testing at extremes to expose fundamental truths
-
-### From ambiguity-guardian agent:
-- **preserving-productive-tensions** - Preserving multiple valid approaches (in architecture skill)
-
-### From knowledge-archaeologist agent:
-- **tracing-knowledge-lineages** - Understanding how ideas evolved (in research skill)
-
-### Dispatch pattern:
-- **when-stuck** - Maps stuck-symptoms to appropriate technique
-
-## What Was Adapted
-
-The Amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
-
-- **Scannable quick-reference guides** (~60-80 lines each)
-- **Symptom-based discovery** via when_to_use descriptions
-- **Immediate application** without special tooling
-- **Composable patterns** through dispatch system
-- **Progressive disclosure** via SKILL.md + references structure
-
-## Core Insight
-
-Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "problem-solving skill", the underlying technique is the same.
-
-We extracted the techniques and made them:
-- Portable across contexts
-- Immediately applicable
-- Token-efficient through progressive disclosure
-- Discoverable through symptom-matching
-- Combinable for complex problems
-
-## License
-
-Original Amplifier project uses MIT License. These adapted skills maintain attribution and follow the same open spirit.
-
-## Adaptation Notes
-
-**Changes from original:**
-- Converted from long-lived agent to scannable reference
-- Added symptom-based dispatch system
-- Removed JSON output requirements
-- Focused on immediate application
-- Added concrete examples
-- Structured for progressive disclosure
-
-**Preserved from original:**
-- Core problem-solving techniques
-- Recognition patterns
-- Application processes
-- Fundamental insights
+# Problem-Solving Skills - Attribution
+
+These skills were derived from agent patterns in the Microsoft Amplifier project.
+
+## Source Repository
+
+- **Name:** Amplifier
+- **URL:** https://github.com/microsoft/amplifier
+- **Commit:** 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
+- **Date:** 2025-10-10
+
+## Skills Derived from Amplifier Agents
+
+### From insight-synthesizer agent:
+- **simplification-cascades** - Finding insights that eliminate multiple components
+- **collision-zone-thinking** - Forcing unrelated concepts together for breakthroughs
+- **meta-pattern-recognition** - Spotting patterns across 3+ domains
+- **inversion-exercise** - Flipping assumptions to reveal alternatives
+- **scale-game** - Testing at extremes to expose fundamental truths
+
+### From ambiguity-guardian agent:
+- **preserving-productive-tensions** - Preserving multiple valid approaches (in architecture skill)
+
+### From knowledge-archaeologist agent:
+- **tracing-knowledge-lineages** - Understanding how ideas evolved (in research skill)
+
+### Dispatch pattern:
+- **when-stuck** - Maps stuck-symptoms to appropriate technique
+
+## What Was Adapted
+
+The Amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
+
+- **Scannable quick-reference guides** (~60-80 lines each)
+- **Symptom-based discovery** via when_to_use descriptions
+- **Immediate application** without special tooling
+- **Composable patterns** through dispatch system
+- **Progressive disclosure** via SKILL.md + references structure
+
+## Core Insight
+
+Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "problem-solving skill", the underlying technique is the same.
+
+We extracted the techniques and made them:
+- Portable across contexts
+- Immediately applicable
+- Token-efficient through progressive disclosure
+- Discoverable through symptom-matching
+- Combinable for complex problems
+
+## License
+
+Original Amplifier project uses MIT License. These adapted skills maintain attribution and follow the same open spirit.
+
+## Adaptation Notes
+
+**Changes from original:**
+- Converted from long-lived agent to scannable reference
+- Added symptom-based dispatch system
+- Removed JSON output requirements
+- Focused on immediate application
+- Added concrete examples
+- Structured for progressive disclosure
+
+**Preserved from original:**
+- Core problem-solving techniques
+- Recognition patterns
+- Application processes
+- Fundamental insights