cokit-cli 1.2.7 → 1.4.0

package/templates/repo/.github/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/templates/repo/.github/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/templates/repo/.github/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

package/templates/repo/.github/skills/ck-repomix/references/usage-patterns.md

@@ -0,0 +1,232 @@
+# Usage Patterns
+
+Practical workflows and patterns for using Repomix in different scenarios.
+
+## AI Analysis Workflows
+
+### Full Repository
+```bash
+repomix --remove-comments --style markdown -o full-repo.md
+```
+**Use:** New codebase, architecture review, complete LLM context, planning
+**Tips:** Remove comments, use markdown, check token limits, review before sharing
+
+### Focused Module
+```bash
+repomix --include "src/auth/**,src/api/**" -o modules.xml
+```
+**Use:** Feature analysis, debugging specific areas, targeted refactoring
+**Tips:** Include related files only, stay within token limits, use XML for AI
+
+### Incremental Analysis
+```bash
+git checkout feature-branch && repomix --include "src/**" -o feature.xml
+git checkout main && repomix --include "src/**" -o main.xml
+```
+**Use:** Feature branch review, change impact, before/after comparison, migration planning
+
+### Cross-Repository
+```bash
+npx repomix --remote org/repo1 -o repo1.xml
+npx repomix --remote org/repo2 -o repo2.xml
+```
+**Use:** Microservices, library comparisons, consistency checks, integration analysis
+
+## Security Audit
+
+### Third-Party Library
+```bash
+npx repomix --remote vendor/library --style xml -o audit.xml
+```
+**Workflow:** Package library → enable security checks → review vulnerabilities → check suspicious patterns → AI analysis
+**Check for:** API keys, hardcoded credentials, network calls, obfuscation, malicious patterns
+
+### Pre-Deployment
+```bash
+repomix --include "src/**,config/**" --style xml -o pre-deploy-audit.xml
+```
+**Checklist:** No sensitive data, no test credentials, env vars correct, security practices, no debug code
+
+### Dependency Audit
+```bash
+repomix --include "**/package.json,**/package-lock.json" -o deps.md --style markdown
+repomix --include "node_modules/suspicious-package/**" -o dep-audit.xml
+```
+**Use:** Suspicious dependency, security advisory, license compliance, vulnerability assessment
+
+### Compliance
+```bash
+repomix --include "src/**,LICENSE,README.md,docs/**" --style markdown -o compliance.md
+```
+**Include:** Source, licenses, docs, configs. **Exclude:** Test data, dependencies
+
+## Documentation
+
+### Doc Context
+```bash
+repomix --include "src/**,docs/**,*.md" --style markdown -o doc-context.md
+```
+**Use:** API docs, architecture docs, user guides, onboarding
+**Tips:** Include existing docs, include source, use markdown
+
+### API Documentation
+```bash
+repomix --include "src/api/**,src/routes/**,src/controllers/**" --remove-comments -o api-context.xml
+```
+**Include:** Routes, controllers, schemas, middleware
+**Workflow:** Package → AI → OpenAPI/Swagger → endpoint docs → examples
+
+### Architecture
+```bash
+repomix --include "src/**/*.ts,*.md" -i "**/*.test.ts" --style markdown -o architecture.md
+```
+**Focus:** Module structure, dependencies, design patterns, data flow
+
+### Examples
+```bash
+repomix --include "examples/**,demos/**,*.example.js" --style markdown -o examples.md
+```
+
+## Library Evaluation
+
+### Quick Assessment
+```bash
+npx repomix --remote owner/library --style markdown -o library-eval.md
+```
+**Evaluate:** Code quality, architecture, dependencies, tests, docs, maintenance
+
+### Feature Comparison
+```bash
+npx repomix --remote owner/lib-a --style xml -o lib-a.xml
+npx repomix --remote owner/lib-b --style xml -o lib-b.xml
+```
+**Compare:** Features, API design, performance, bundle size, dependencies, maintenance
+
+### Integration Feasibility
+```bash
+npx repomix --remote vendor/library --include "src/**,*.md" -o library.xml
+repomix --include "src/integrations/**" -o our-integrations.xml
+```
+Analyze compatibility between target library and your integration points
+
+### Migration Planning
+```bash
+repomix --include "node_modules/old-lib/**" -o old-lib.xml
+npx repomix --remote owner/new-lib -o new-lib.xml
+```
+Compare current vs target library, analyze usage patterns
+
+## Workflow Integration
+
+### CI/CD
+```yaml
+# GitHub Actions
+- name: Generate Snapshot
+  run: |
+    npm install -g repomix
+    repomix --style markdown -o release-snapshot.md
+- name: Upload Artifact
+  uses: actions/upload-artifact@v3
+  with: {name: repo-snapshot, path: release-snapshot.md}
+```
+**Use:** Release docs, compliance archives, change tracking, audit trails
+
+### Git Hooks
+```bash
+#!/bin/bash
+# .git/hooks/pre-commit
+git diff --cached --name-only > staged-files.txt
+repomix --include "$(cat staged-files.txt | tr '\n' ',')" -o .context/latest.xml
+```
+
+### IDE (VS Code)
+```json
+{"version": "2.0.0", "tasks": [{"label": "Package for AI", "type": "shell", "command": "repomix --include 'src/**' --remove-comments --copy"}]}
+```
+
+### Copilot
+```bash
+repomix --style markdown --copy  # Then paste into Copilot chat
+```
+
+## Language-Specific Patterns
+
+### TypeScript
+```bash
+repomix --include "**/*.ts,**/*.tsx" --remove-comments --no-line-numbers
+```
+**Exclude:** `**/*.test.ts`, `dist/`, `coverage/`
+
+### React
+```bash
+repomix --include "src/**/*.{js,jsx,ts,tsx},public/**" -i "build/,*.test.*"
+```
+**Include:** Components, hooks, utils, public assets
+
+### Node.js Backend
+```bash
+repomix --include "src/**/*.js,config/**" -i "node_modules/,logs/,tmp/"
+```
+**Focus:** Routes, controllers, models, middleware, configs
+
+### Python
+```bash
+repomix --include "**/*.py,requirements.txt,*.md" -i "**/__pycache__/,venv/"
+```
+**Exclude:** `__pycache__/`, `*.pyc`, `venv/`, `.pytest_cache/`
+
+### Monorepo
+```bash
+repomix --include "packages/*/src/**" -i "packages/*/node_modules/,packages/*/dist/"
+```
+**Consider:** Package-specific patterns, shared deps, cross-package refs, workspace structure
+
+## Troubleshooting
+
+### Output Too Large
+**Problem:** Exceeds LLM token limits
+**Fix:**
+```bash
+repomix -i "node_modules/**,dist/**,coverage/**" --include "src/core/**" --remove-comments --no-line-numbers
+```
+
+### Missing Files
+**Problem:** Expected files not included
+**Debug:**
+```bash
+cat .gitignore .repomixignore  # Check ignore patterns
+repomix --no-gitignore --no-default-patterns --verbose
+```
+
+### Sensitive Data Warnings
+**Problem:** Security scanner flags secrets
+**Actions:** Review files → add to `.repomixignore` → remove sensitive data → use env vars
+```bash
+repomix --no-security-check  # Use carefully for false positives
+```
+
+### Performance Issues
+**Problem:** Slow on large repo
+**Optimize:**
+```bash
+repomix --include "src/**/*.ts" -i "node_modules/**,dist/**,vendor/**"
+```
+
+### Remote Access
+**Problem:** Cannot access remote repo
+**Fix:**
+```bash
+npx repomix --remote https://github.com/owner/repo  # Full URL
+npx repomix --remote https://github.com/owner/repo/commit/abc123  # Specific commit
+# For private: clone first, run locally
+```
+
+## Best Practices
+
+**Planning:** Define scope → identify files → check token limits → consider security
+
+**Execution:** Start broad, refine narrow → use appropriate format → enable security checks → monitor tokens
+
+**Review:** Verify no sensitive data → check completeness → validate format → test with LLM
+
+**Iteration:** Refine patterns → adjust format → optimize tokens → document patterns