cokit-cli 1.2.7 → 1.4.0

package/skills/ck-project-management/references/progress-tracking.md

@@ -0,0 +1,120 @@
+# Progress Tracking
+
+## Plan Analysis Workflow
+
+1. **Read plans directory:** Glob `./plans/*/plan.md` to discover all plans
+2. **Parse YAML frontmatter:** Extract status, priority, effort, branch, tags
+3. **Scan phase files:** Count `[x]` (done) vs `[ ]` (remaining) in each phase
+4. **Reconcile completed tasks:** Ensure all completed task metadata is reflected in phase files (backfill stale earlier phases first)
+5. **Calculate progress:** `completed / total * 100` per plan
+6. **Cross-reference:** Compare plan tasks against actual implementation
+
+## Status Update Protocol
+
+### CLI-First Status Updates (Preferred)
+
+Use `ck plan` CLI commands for deterministic, format-safe status changes:
+
+```bash
+# Mark phase completed
+ck plan check <phase-id>
+
+# Mark phase in-progress
+ck plan check <phase-id> --start
+
+# Revert phase to pending
+ck plan uncheck <phase-id>
+
+# Add new phase or sub-phase
+ck plan add-phase "Phase Name" [--after <id>]
+```
+
+CLI automatically updates both `plan.md` table AND phase file frontmatter.
+Plan-level status auto-computed: all completed → `completed`, any in-progress → `in-progress`.
+
+**Fallback:** If `ck` CLI is not available, edit `plan.md` directly —
+only change the Status column cell, preserve table structure exactly.
+
+### Plan-Level Status
+
+Update `plan.md` frontmatter `status` field:
+
+| Condition | Status |
+|-----------|--------|
+| No phases started | `pending` |
+| Any phase in progress | `in-progress` |
+| All phases complete | `completed` |
+
+### Phase-Level Status
+
+Each `phase-XX-*.md` tracks with checkboxes:
+- `[ ]` = pending
+- `[x]` = completed
+- Count ratio for progress percentage
+
+### Task-Level Status
+
+Tasks (session-scoped): `pending` → `in_progress` → `completed`
+
+### Reconciliation Rule
+
+If a later phase is marked done while earlier phases still contain stale unchecked completed items, backfill earlier phases in the same sync pass before final status reporting.
+
+## Verification Checklist
+
+When verifying task completeness:
+
+1. **Acceptance criteria met?** — Check against plan requirements
+2. **Code quality validated?** — code-reviewer agent report available?
+3. **Tests passing?** — tester agent report confirms 100% pass?
+4. **Documentation updated?** — docs match implementation?
+5. **No regressions?** — Existing functionality intact?
+
+## Report Generation
+
+### Status Summary Template
+
+```markdown
+## Project Status: [Date]
+
+### Active Plans
+| Plan | Progress | Priority | Status | Branch |
+|------|----------|----------|--------|--------|
+| [name] | [X]% | P[N] | [status] | [branch] |
+
+### Completed This Session
+- [x] [description]
+
+### Blockers & Risks
+- [ ] [description] — [mitigation]
+
+### Next Steps
+1. [Priority action]
+2. [Follow-up]
+```
+
+### Detailed Report Template
+
+```markdown
+## [Plan Name] - Detailed Status
+
+### Achievements
+- Completed features, resolved issues, delivered value
+
+### Testing Status
+- Components needing validation, test scenarios, quality gates
+
+### Risk Assessment
+- Potential blockers, technical debt, mitigation strategies
+
+### Recommendations
+- Prioritized next steps, resource needs, timeline projections
+```
+
+## Metrics to Track
+
+- **Phase completion %** — How much of each phase is done
+- **Blocker count** — Open blockers preventing progress
+- **Dependency chain health** — Any circular or stale dependencies
+- **Time since last update** — Identify stale plans needing attention
+- **Test coverage** — Per-feature test pass rates

package/skills/ck-project-management/references/reporting-patterns.md

@@ -0,0 +1,94 @@
+# Reporting Patterns
+
+## Report Types
+
+### 1. Session Status Report
+
+Quick summary of work done in current session.
+
+```markdown
+## Session Report: [Date]
+
+### Work Completed
+- [x] [Task/feature description]
+- [x] [Task/feature description]
+
+### In Progress
+- [ ] [Task description] — [% complete, blocker if any]
+
+### Tasks Created
+- [N] tasks hydrated from [plan]
+- [M] completed, [K] remaining
+
+### Next Session
+1. [Priority item]
+2. [Follow-up item]
+```
+
+### 2. Plan Completion Report
+
+Comprehensive summary when a plan reaches completion.
+
+```markdown
+## Plan Complete: [Plan Name]
+
+### Summary
+- **Duration:** [start] → [end]
+- **Phases:** [N] completed
+- **Files changed:** [count]
+- **Tests:** [pass/total]
+
+### Achievements
+- [Feature/capability delivered]
+
+### Known Limitations
+- [Any caveats or future work needed]
+
+### Documentation Updates
+- [Which docs were updated]
+```
+
+### 3. Progress Report (Multi-Plan)
+
+Overview across all active plans.
+
+```markdown
+## Project Progress: [Date]
+
+| Plan | Status | Progress | Priority | Next Action |
+|------|--------|----------|----------|-------------|
+| [name] | [status] | [%] | P[N] | [action] |
+
+### Highlights
+- [Key achievement or milestone]
+
+### Risks
+- [Risk] — [Mitigation]
+
+### Blockers
+- [Blocker] — [Resolution path]
+```
+
+## Report Naming
+
+Use pattern from `## Naming` section injected by hooks:
+`{reports-path}/pm-{date}-{time}-{slug}.md`
+
+Example: `plans/reports/pm-260205-2221-auth-progress.md`
+
+## Report Generation Workflow
+
+1. `TaskList()` → gather all task statuses
+2. Glob `./plans/*/plan.md` → scan active plans
+3. Read phase files → count checkboxes
+4. Compile metrics into report template
+5. Write to reports directory
+6. Highlight: achievements, blockers, risks, next steps
+
+## Concision Rules
+
+- Sacrifice grammar for brevity
+- Use tables over paragraphs where possible
+- List unresolved questions at end
+- Metrics > prose (use numbers, percentages)
+- Skip obvious context; focus on actionable insights

package/skills/ck-project-management/references/task-operations.md

@@ -0,0 +1,87 @@
+# Task Operations Reference
+
+Copilot provides 4 native tools for session-scoped task management.
+
+**Tool Availability:** `TaskCreate`, `TaskUpdate`, `TaskGet`, `TaskList` are **CLI-only** — disabled in VSCode extension (`isTTY` check). If these tools error, fall back to `TodoWrite` for progress tracking. Plan file sync-back works identically without Task tools.
+
+## TaskCreate
+
+Create structured tasks with metadata and dependencies.
+
+```
+TaskCreate(
+  subject: "Implement JWT auth middleware",
+  description: "Add JWT validation to API routes. Verify tokens, extract claims, attach to context.",
+  activeForm: "Implementing JWT auth middleware",
+  metadata: { feature: "auth", phase: 2, priority: "P1", effort: "2h",
+              planDir: "plans/260205-auth/", phaseFile: "phase-02-api.md" }
+)
+```
+
+**Parameters:**
+- `subject` (required): Imperative title, <60 chars ("Implement X", "Add Y", "Fix Z")
+- `description` (required): Detailed requirements + acceptance criteria
+- `activeForm` (optional): Present-continuous shown in spinner ("Implementing X")
+- `metadata` (optional): Arbitrary key-value pairs for tracking
+
+**Required metadata fields:** `phase`, `priority` (P1/P2/P3), `effort`, `planDir`, `phaseFile`
+**Optional metadata:** `step`, `critical`, `riskLevel`, `dependencies`, `feature`, `owner`
+
+## TaskUpdate
+
+Manage state transitions and dependency chains.
+
+```
+TaskUpdate(
+  taskId: "task-123",
+  status: "in_progress",
+  addBlockedBy: ["task-122"]
+)
+```
+
+**Status lifecycle:** `pending` → `in_progress` → `completed`
+
+**Dependency fields:**
+- `addBlockedBy`: "I cannot start until these tasks complete"
+- `addBlocks`: "These tasks cannot start until I complete"
+- `owner`: Assign to specific agent
+
+When a blocking task completes, dependent tasks auto-unblock.
+
+## TaskGet & TaskList
+
+- `TaskGet(taskId)` → Full task details including dependencies
+- `TaskList()` → All tasks with status, owner, blockedBy
+
+**Task is "available" when:** status=`pending`, no owner, blockedBy list empty.
+
+## Dependency Patterns
+
+```
+Phase 1 (no blockers)              ← start here
+Phase 2 (addBlockedBy: [P1-id])    ← auto-unblocked when P1 completes
+Phase 3 (addBlockedBy: [P2-id])
+Step 3.4 (addBlockedBy: [P2-id])   ← critical steps share phase dependency
+```
+
+## When to Use Tasks
+
+| Scenario | Tasks? | Why |
+|----------|--------|-----|
+| Multi-phase feature (3+) | Yes | Track progress, enable parallel |
+| Complex dependencies | Yes | Automatic unblocking |
+| Parallel agent work | Yes | Shared progress tracking |
+| Single-phase quick fix | No | Overhead exceeds benefit |
+| <3 related steps | No | Just do them directly |
+
+**3-Task Rule:** <3 tasks → skip creation, overhead not worth it.
+
+## Parallel Agent Coordination
+
+1. Create tasks with scoped ownership per agent
+2. Each agent works in designated directories only
+3. When Agent A completes a task → `TaskUpdate(status: "completed")`
+4. Tasks blocked by completed work auto-unblock
+5. Agent B (or A) claims newly available work
+
+**Key:** Assign `owner` field to prevent agents from claiming same task.

package/skills/ck-repomix/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: ck-repomix
+description: Pack repositories into AI-friendly files with Repomix (XML, Markdown, plain text). Use for codebase snapshots, LLM context preparation, security audits, third-party library analysis.
+argument-hint: "[path] [--style xml|markdown|plain|json]"
+---
+
+# Repomix Skill
+
+Repomix packs entire repositories into single, AI-friendly files. Perfect for feeding codebases to LLMs like Copilot, ChatGPT, and Gemini.
+
+## When to Use
+
+Use when:
+- Packaging codebases for AI analysis
+- Creating repository snapshots for LLM context
+- Analyzing third-party libraries
+- Preparing for security audits
+- Generating documentation context
+- Investigating bugs across large codebases
+- Creating AI-friendly code representations
+
+## Quick Start
+
+### Check Installation
+```bash
+repomix --version
+```
+
+### Install
+```bash
+# npm
+npm install -g repomix
+
+# Homebrew (macOS/Linux)
+brew install repomix
+```
+
+### Basic Usage
+```bash
+# Package current directory (generates repomix-output.xml)
+repomix
+
+# Specify output format
+repomix --style markdown
+repomix --style json
+
+# Package remote repository
+npx repomix --remote owner/repo
+
+# Custom output with filters
+repomix --include "src/**/*.ts" --remove-comments -o output.md
+```
+
+## Core Capabilities
+
+### Repository Packaging
+- AI-optimized formatting with clear separators
+- Multiple output formats: XML, Markdown, JSON, Plain text
+- Git-aware processing (respects .gitignore)
+- Token counting for LLM context management
+- Security checks for sensitive information
+
+### Remote Repository Support
+Process remote repositories without cloning:
+```bash
+# Shorthand
+npx repomix --remote yamadashy/repomix
+
+# Full URL
+npx repomix --remote https://github.com/owner/repo
+
+# Specific commit
+npx repomix --remote https://github.com/owner/repo/commit/hash
+```
+
+### Comment Removal
+Strip comments from supported languages (HTML, CSS, JavaScript, TypeScript, Vue, Svelte, Python, PHP, Ruby, C, C#, Java, Go, Rust, Swift, Kotlin, Dart, Shell, YAML):
+```bash
+repomix --remove-comments
+```
+
+## Common Use Cases
+
+### Code Review Preparation
+```bash
+# Package feature branch for AI review
+repomix --include "src/**/*.ts" --remove-comments -o review.md --style markdown
+```
+
+### Security Audit
+```bash
+# Package third-party library
+npx repomix --remote vendor/library --style xml -o audit.xml
+```
+
+### Documentation Generation
+```bash
+# Package with docs and code
+repomix --include "src/**,docs/**,*.md" --style markdown -o context.md
+```
+
+### Bug Investigation
+```bash
+# Package specific modules
+repomix --include "src/auth/**,src/api/**" -o debug-context.xml
+```
+
+### Implementation Planning
+```bash
+# Full codebase context
+repomix --remove-comments --copy
+```
+
+## Command Line Reference
+
+### File Selection
+```bash
+# Include specific patterns
+repomix --include "src/**/*.ts,*.md"
+
+# Ignore additional patterns
+repomix -i "tests/**,*.test.js"
+
+# Disable .gitignore rules
+repomix --no-gitignore
+```
+
+### Output Options
+```bash
+# Output format
+repomix --style markdown  # or xml, json, plain
+
+# Output file path
+repomix -o output.md
+
+# Remove comments
+repomix --remove-comments
+
+# Copy to clipboard
+repomix --copy
+```
+
+### Configuration
+```bash
+# Use custom config file
+repomix -c custom-config.json
+
+# Initialize new config
+repomix --init  # creates repomix.config.json
+```
+
+## Token Management
+
+Repomix automatically counts tokens for individual files, total repository, and per-format output.
+
+Typical LLM context limits:
+- Copilot: ~200K tokens
+- GPT-4: ~128K tokens
+- GPT-3.5: ~16K tokens
+
+### Token Count Optimization
+Understanding your codebase's token distribution is crucial for optimizing AI interactions. Use the --token-count-tree option to visualize token usage across your project:
+
+```bash
+repomix --token-count-tree
+```
+This displays a hierarchical view of your codebase with token counts:
+
+```
+🔢 Token Count Tree:
+────────────────────
+└── src/ (70,925 tokens)
+    ├── cli/ (12,714 tokens)
+    │   ├── actions/ (7,546 tokens)
+    │   └── reporters/ (990 tokens)
+    └── core/ (41,600 tokens)
+        ├── file/ (10,098 tokens)
+        └── output/ (5,808 tokens)
+```
+You can also set a minimum token threshold to focus on larger files:
+
+```bash
+repomix --token-count-tree 1000  # Only show files/directories with 1000+ tokens
+```
+
+This helps you:
+
+- Identify token-heavy files that might exceed AI context limits
+- Optimize file selection using --include and --ignore patterns
+- Plan compression strategies by targeting the largest contributors
+- Balance content vs. context when preparing code for AI analysis
+
+## Security Considerations
+
+Repomix uses Secretlint to detect sensitive data (API keys, passwords, credentials, private keys, AWS secrets).
+
+Best practices:
+1. Always review output before sharing
+2. Use `.repomixignore` for sensitive files
+3. Enable security checks for unknown codebases
+4. Avoid packaging `.env` files
+5. Check for hardcoded credentials
+
+Disable security checks if needed:
+```bash
+repomix --no-security-check
+```
+
+## Implementation Workflow
+
+When user requests repository packaging:
+
+1. **Assess Requirements**
+   - Identify target repository (local/remote)
+   - Determine output format needed
+   - Check for sensitive data concerns
+
+2. **Configure Filters**
+   - Set include patterns for relevant files
+   - Add ignore patterns for unnecessary files
+   - Enable/disable comment removal
+
+3. **Execute Packaging**
+   - Run repomix with appropriate options
+   - Monitor token counts
+   - Verify security checks
+
+4. **Validate Output**
+   - Review generated file
+   - Confirm no sensitive data
+   - Check token limits for target LLM
+
+5. **Deliver Context**
+   - Provide packaged file to user
+   - Include token count summary
+   - Note any warnings or issues
+
+## Reference Documentation
+
+For detailed information, see:
+- [Configuration Reference](./references/configuration.md) - Config files, include/exclude patterns, output formats, advanced options
+- [Usage Patterns](./references/usage-patterns.md) - AI analysis workflows, security audit preparation, documentation generation, library evaluation
+
+## Additional Resources
+
+- GitHub: https://github.com/yamadashy/repomix
+- Documentation: https://repomix.com/guide/
+- MCP Server: Available for AI assistant integration