cokit-cli 1.0.0

package/skills/debugging/references/systematic-debugging.md

@@ -0,0 +1,74 @@
+# Systematic Debugging
+
+Four-phase framework ensuring proper investigation before fixes.
+
+## Phase 1: Root Cause Investigation
+
+Before ANY fix attempt:
+
+1. **Read the full error**
+   - Stack trace, line numbers, error type
+   - Don't skim - read word by word
+
+2. **Reproduce consistently**
+   - Can you trigger it reliably?
+   - What are the exact steps?
+
+3. **Check recent changes**
+   - What changed since it last worked?
+   - git diff, recent commits
+
+4. **Gather evidence**
+   - Add logging if needed
+   - Check inputs and outputs
+   - Don't guess - observe
+
+## Phase 2: Pattern Analysis
+
+1. **Find working example**
+   - Similar code that works
+   - Previous version that worked
+
+2. **Compare systematically**
+   - Line by line comparison
+   - What's different?
+
+3. **Identify key difference**
+   - What's the minimal difference?
+   - What assumption changed?
+
+## Phase 3: Hypothesis and Testing
+
+1. **Form specific theory**
+   - "The bug is caused by X because Y"
+   - Must be testable
+
+2. **Test minimally**
+   - Smallest change to prove/disprove
+   - Don't fix yet - just test theory
+
+3. **Verify theory**
+   - Did prediction match result?
+   - If not, return to Phase 1
+
+## Phase 4: Implementation
+
+1. **Write failing test first**
+   - Test should fail before fix
+   - Proves you understand bug
+
+2. **Make minimal fix**
+   - Fix at root cause
+   - Don't add workarounds
+
+3. **Verify fix works**
+   - Test passes now
+   - No regressions
+   - Fresh run, not cached
+
+## Key Rules
+
+- Complete each phase before proceeding
+- No fixes without Phase 1 evidence
+- Theory must be testable
+- Verify every claim

package/skills/debugging/references/verification.md

@@ -0,0 +1,74 @@
+# Verification Protocol
+
+Run verification commands and confirm output before claiming success.
+
+## Core Rule
+
+**NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE**
+
+"Should work" is not evidence. Run it. Read the output. Then claim.
+
+## Verification Steps
+
+### 1. Run Fresh
+
+- Clear cache if applicable
+- Run from clean state
+- Don't rely on previous runs
+
+### 2. Read Output
+
+- Read the actual output
+- Don't assume it passed
+- Check for warnings too
+
+### 3. Confirm Expectations
+
+- Did it do what you expected?
+- All tests pass (not just most)?
+- No new warnings/errors?
+
+### 4. Document Evidence
+
+- Copy relevant output
+- Note what was verified
+- Timestamp if needed
+
+## What to Verify
+
+Before claiming "fixed":
+- [ ] Tests pass (fresh run)
+- [ ] No new errors in logs
+- [ ] Feature works manually
+- [ ] Edge cases handled
+
+Before claiming "complete":
+- [ ] All acceptance criteria met
+- [ ] Tests cover new code
+- [ ] No regressions
+- [ ] Documentation updated
+
+## Anti-Patterns
+
+**Don't do:**
+- "Tests passed earlier"
+- "It worked on my machine"
+- "Should be fine now"
+- Skipping verification because confident
+
+**Do instead:**
+- Run fresh every time
+- Read actual output
+- Verify on clean state
+- Question assumptions
+
+## Verification Checklist
+
+```
+[ ] Ran command fresh (not cached)
+[ ] Read full output (not skimmed)
+[ ] Output matches expectations
+[ ] No warnings or errors
+[ ] Tested edge case
+[ ] Documented result
+```

package/skills/docs-seeker/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: docs-seeker
+description: Find and reference technical documentation. Use when needing API docs, library references, or implementation examples.
+---
+
+# Docs Seeker
+
+Find relevant technical documentation efficiently.
+
+## When to Use
+
+- Need API documentation
+- Looking for library examples
+- Researching best practices
+- Finding implementation guides
+- Unknown technology referenced
+
+## Search Strategy
+
+### 1. Identify What's Needed
+
+- API reference?
+- Tutorial/guide?
+- Code examples?
+- Best practices?
+
+### 2. Search Sources
+
+Priority order:
+1. Official documentation
+2. GitHub repositories
+3. Stack Overflow (verified answers)
+4. Technical blogs (reputable)
+
+### 3. Validate Information
+
+- Check date (is it current?)
+- Check source (is it authoritative?)
+- Check version (matches your version?)
+
+## Documentation Types
+
+### API Reference
+- Function signatures
+- Parameters and return types
+- Error codes
+
+### Tutorials
+- Step-by-step guides
+- Getting started
+- Common patterns
+
+### Examples
+- Working code samples
+- Real-world usage
+- Edge case handling
+
+## Search Tips
+
+### For Libraries
+```
+[library name] documentation
+[library name] [specific feature] example
+[library name] [version] migration guide
+```
+
+### For APIs
+```
+[service] API reference
+[service] [endpoint] documentation
+[service] authentication guide
+```
+
+### For Errors
+```
+[error message] [language/framework]
+[error code] [library name]
+```
+
+## Quality Checks
+
+- [ ] Source is official/reputable?
+- [ ] Information is current?
+- [ ] Version matches?
+- [ ] Examples work?
+
+## References
+
+See `./references/` for detailed guides:
+- `search-patterns.md` - Search strategies
+- `source-evaluation.md` - Evaluating sources

package/skills/docs-seeker/references/search-patterns.md

@@ -0,0 +1,93 @@
+# Search Patterns
+
+Effective patterns for finding documentation.
+
+## Library Documentation
+
+### Getting Started
+```
+[library] getting started
+[library] quickstart guide
+[library] tutorial for beginners
+```
+
+### Specific Features
+```
+[library] [feature] example
+[library] how to [action]
+[library] [feature] documentation
+```
+
+### Version-Specific
+```
+[library] [version] changelog
+[library] [version] migration
+[library] [version] breaking changes
+```
+
+### Troubleshooting
+```
+[library] [error message]
+[library] [error code] fix
+[library] common issues
+```
+
+## API Documentation
+
+### Authentication
+```
+[service] API authentication
+[service] API key setup
+[service] OAuth implementation
+```
+
+### Endpoints
+```
+[service] API [endpoint] reference
+[service] [resource] API documentation
+[service] REST API examples
+```
+
+### Rate Limits
+```
+[service] API rate limits
+[service] API quotas
+[service] API throttling
+```
+
+## Framework Documentation
+
+### Core Concepts
+```
+[framework] core concepts
+[framework] architecture guide
+[framework] fundamentals
+```
+
+### Patterns
+```
+[framework] best practices
+[framework] [pattern] example
+[framework] recommended approach
+```
+
+### Integration
+```
+[framework] [library] integration
+[framework] with [tool]
+[framework] [database] setup
+```
+
+## Source Priority
+
+1. **Official docs** - Most authoritative
+2. **GitHub repos** - Real implementations
+3. **Stack Overflow** - Community solutions
+4. **Blogs** - Tutorials and explanations
+
+## Red Flags
+
+- Outdated (check date)
+- Wrong version
+- Unverified source
+- No working examples

package/skills/docs-seeker/references/source-evaluation.md

@@ -0,0 +1,77 @@
+# Source Evaluation
+
+How to evaluate documentation sources for reliability.
+
+## Evaluation Criteria
+
+### Authority
+- Official documentation?
+- Recognized expert author?
+- Reputable organization?
+- Community-verified?
+
+### Currency
+- Publication date visible?
+- Last updated recently?
+- Version matches yours?
+- Active maintenance?
+
+### Accuracy
+- Code examples work?
+- Information consistent?
+- Cross-referenced?
+- No obvious errors?
+
+### Completeness
+- Covers your use case?
+- Explains edge cases?
+- Includes examples?
+- Links to related docs?
+
+## Source Ranking
+
+### Tier 1: Official Sources
+- Official documentation
+- API references
+- Official tutorials
+- Release notes
+
+### Tier 2: Primary Sources
+- GitHub repositories
+- Author blogs
+- Conference talks
+- RFC documents
+
+### Tier 3: Community Sources
+- Stack Overflow (verified)
+- Community tutorials
+- Technical blogs
+- Forum discussions
+
+### Tier 4: Use with Caution
+- Outdated articles
+- Unverified answers
+- AI-generated content
+- Anonymous sources
+
+## Red Flags
+
+### Content Issues
+- No date/version info
+- Broken code examples
+- Outdated dependencies
+- Copy-pasted errors
+
+### Source Issues
+- Unknown author
+- No references
+- Clickbait title
+- Excessive ads
+
+## Validation Checklist
+
+- [ ] Source is authoritative?
+- [ ] Content is current?
+- [ ] Version matches?
+- [ ] Examples tested?
+- [ ] Cross-referenced?

package/skills/planning/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: planning
+description: Create technical implementation plans through research, analysis, and design. Use when planning features, architecting systems, or breaking down complex requirements.
+---
+
+# Planning
+
+Create detailed implementation plans before writing code.
+
+## Core Principles
+
+- **YAGNI**, **KISS**, **DRY**
+- Plan quality determines implementation success
+- Research before designing
+
+## When to Use
+
+- Planning new feature implementations
+- Architecting system designs
+- Evaluating technical approaches
+- Breaking down complex requirements
+- Assessing technical trade-offs
+
+## Planning Workflow
+
+### 1. Research & Analysis
+- Understand requirements fully
+- Research existing solutions
+- Identify constraints and risks
+
+### 2. Codebase Understanding
+- Read existing code patterns
+- Identify integration points
+- Note dependencies
+
+### 3. Solution Design
+- Design architecture
+- Consider alternatives
+- Evaluate trade-offs
+
+### 4. Plan Documentation
+- Write clear plan document
+- Break into phases
+- Define success criteria
+
+### 5. Review & Refine
+- Verify completeness
+- Check actionability
+- Get stakeholder input
+
+## Output Requirements
+
+- **DO NOT** implement code - only create plans
+- Plans must be self-contained
+- Include code snippets for clarity
+- Provide multiple options when applicable
+
+## Plan Structure
+
+```
+plans/
+└── YYMMDD-plan-name/
+    ├── plan.md           # Main plan
+    ├── phase-01-xxx.md   # Phase details
+    ├── phase-02-xxx.md
+    └── research/         # Research notes
+```
+
+## Quality Standards
+
+- Thorough and specific
+- Consider maintainability
+- Address security concerns
+- Detailed enough for any developer
+- Validate against existing patterns
+
+## References
+
+See `./references/` for detailed guides:
+- `research-phase.md` - Research methodology
+- `solution-design.md` - Design patterns
+- `plan-organization.md` - Plan structure

package/skills/planning/references/plan-organization.md

@@ -0,0 +1,88 @@
+# Plan Organization
+
+How to structure implementation plans.
+
+## Plan Document Structure
+
+```markdown
+---
+title: "Feature Name"
+status: pending
+effort: Xh
+created: YYYY-MM-DD
+---
+
+# Plan Title
+
+## Overview
+[2-3 sentences describing what and why]
+
+## Goals
+- [ ] Goal 1
+- [ ] Goal 2
+
+## Non-Goals
+- Thing we're not doing
+- Thing deferred to later
+
+## Design
+[Architecture overview]
+
+## Phases
+
+| Phase | Description | Effort |
+|-------|-------------|--------|
+| 1 | Setup | 1h |
+| 2 | Core feature | 2h |
+| 3 | Testing | 1h |
+
+## Risks
+- Risk 1: [mitigation]
+- Risk 2: [mitigation]
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+```
+
+## Phase Documents
+
+Each phase gets its own file:
+
+```markdown
+# Phase N: Name
+
+**Effort:** Xh | **Status:** Pending
+
+## Objective
+[What this phase accomplishes]
+
+## Tasks
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+```
+
+## File Organization
+
+```
+plans/
+└── YYMMDD-feature-name/
+    ├── plan.md
+    ├── phase-01-setup.md
+    ├── phase-02-implementation.md
+    ├── phase-03-testing.md
+    └── research/
+        └── notes.md
+```
+
+## Quality Checks
+
+- [ ] Clear structure?
+- [ ] Tasks actionable?
+- [ ] Effort estimated?
+- [ ] Success criteria defined?

package/skills/planning/references/research-phase.md

@@ -0,0 +1,56 @@
+# Research Phase
+
+How to properly research before planning.
+
+## Goals
+
+- Understand problem space
+- Find existing solutions
+- Identify constraints
+- Avoid reinventing wheels
+
+## Research Steps
+
+### 1. Understand Requirements
+
+- What exactly needs to be built?
+- What's the success criteria?
+- What are the constraints?
+- Who are the stakeholders?
+
+### 2. Research Existing Solutions
+
+- How do others solve this?
+- What libraries/tools exist?
+- What patterns are common?
+- What pitfalls to avoid?
+
+### 3. Analyze Codebase
+
+- What exists already?
+- What patterns are used?
+- What can be reused?
+- What needs to change?
+
+### 4. Identify Risks
+
+- What could go wrong?
+- What's uncertain?
+- What needs clarification?
+- What are blockers?
+
+## Research Output
+
+Document findings:
+- Problem summary
+- Existing solutions
+- Recommended approach
+- Risks and mitigations
+- Open questions
+
+## Quality Checks
+
+- [ ] Requirements clear?
+- [ ] Alternatives considered?
+- [ ] Risks identified?
+- [ ] Questions listed?

package/skills/planning/references/solution-design.md

@@ -0,0 +1,65 @@
+# Solution Design
+
+How to design solutions before implementing.
+
+## Design Process
+
+### 1. Define Scope
+
+- What's included?
+- What's excluded?
+- What's the MVP?
+- What's future work?
+
+### 2. Architecture
+
+- High-level structure
+- Component breakdown
+- Data flow
+- Integration points
+
+### 3. Consider Alternatives
+
+For each major decision:
+- Option A: [description]
+- Option B: [description]
+- Recommendation: [choice + reasoning]
+
+### 4. Trade-offs
+
+Document trade-offs:
+- Performance vs simplicity
+- Flexibility vs complexity
+- Speed vs quality
+
+## Design Output
+
+### Architecture Document
+
+```markdown
+## Overview
+[1-2 sentences]
+
+## Components
+- Component A: [purpose]
+- Component B: [purpose]
+
+## Data Flow
+[diagram or description]
+
+## Key Decisions
+- Decision 1: [choice + why]
+- Decision 2: [choice + why]
+
+## Trade-offs
+- [trade-off 1]
+- [trade-off 2]
+```
+
+## Quality Checks
+
+- [ ] Scope clear?
+- [ ] Components defined?
+- [ ] Alternatives considered?
+- [ ] Trade-offs documented?
+- [ ] Fits existing patterns?