cokit-cli 1.0.9 → 1.2.2

package/templates/repo/.github/skills/docs-seeker/scripts/utils/env-loader.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+/**
+ * Environment variable loader for docs-seeker skill
+ * Respects order: process.env > skill/.env > skills/.env > $HOME/.copilot/.env
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse .env file content into key-value pairs
+ * @param {string} content - .env file content
+ * @returns {Object} Parsed environment variables
+ */
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    // Skip comments and empty lines
+    if (!line || line.trim().startsWith('#')) continue;
+
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2].trim();
+
+      // Remove quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      env[key] = value;
+    }
+  }
+
+  return env;
+}
+
+/**
+ * Load environment variables from .env files in priority order
+ * Priority: process.env > skill/.env > skills/.env > $HOME/.copilot/.env
+ * @returns {Object} Merged environment variables
+ */
+function loadEnv() {
+  const skillDir = path.resolve(__dirname, '../..');
+  const skillsDir = path.resolve(skillDir, '..');
+  const configDir = path.resolve(skillsDir, '..');
+
+  const envPaths = [
+    path.join(configDir, '.env'),      // Lowest priority
+    path.join(skillsDir, '.env'),
+    path.join(skillDir, '.env'),       // Highest priority (file)
+  ];
+
+  let mergedEnv = {};
+
+  // Load .env files in order (lowest to highest priority)
+  for (const envPath of envPaths) {
+    if (fs.existsSync(envPath)) {
+      try {
+        const content = fs.readFileSync(envPath, 'utf8');
+        const parsed = parseEnvFile(content);
+        mergedEnv = { ...mergedEnv, ...parsed };
+      } catch (error) {
+        // Silently skip unreadable files
+      }
+    }
+  }
+
+  // process.env has highest priority
+  mergedEnv = { ...mergedEnv, ...process.env };
+
+  return mergedEnv;
+}
+
+/**
+ * Get environment variable with fallback
+ * @param {string} key - Environment variable key
+ * @param {string} defaultValue - Default value if not found
+ * @returns {string} Environment variable value
+ */
+function getEnv(key, defaultValue = '') {
+  const env = loadEnv();
+  return env[key] || defaultValue;
+}
+
+module.exports = {
+  loadEnv,
+  getEnv,
+  parseEnvFile,
+};

package/templates/repo/.github/skills/docs-seeker/workflows/library-search.md

@@ -0,0 +1,86 @@
+# General Library Documentation Search
+
+**Use when:** User asks about entire library/framework
+
+**Speed:** ⚡⚡ Moderate (30-60s)
+**Token usage:** 🟡 Medium
+**Accuracy:** 📚 Comprehensive
+
+## Trigger Patterns
+
+- "Documentation for [LIBRARY]"
+- "[LIBRARY] getting started"
+- "How to use [LIBRARY]"
+- "[LIBRARY] API reference"
+
+## Workflow (Script-First)
+
+```bash
+# STEP 1: Execute detect-topic.js script
+node scripts/detect-topic.js "<user query>"
+# Returns: {"isTopicSpecific": false} for general queries
+
+# STEP 2: Execute fetch-docs.js script (handles URL construction)
+node scripts/fetch-docs.js "<user query>"
+# Script constructs context7.com URL automatically
+# Script handles GitHub/website URL patterns
+# Returns: llms.txt content with 5-20+ URLs
+
+# STEP 3: Execute analyze-llms-txt.js script
+cat llms.txt | node scripts/analyze-llms-txt.js -
+# Groups URLs: critical, important, supplementary
+# Recommends: agent distribution strategy
+# Returns: {totalUrls, grouped, distribution}
+
+# STEP 4: Deploy agents based on script recommendation
+# - 1-3 URLs: Single agent or direct WebFetch
+# - 4-10 URLs: Deploy 3-5 Explorer agents
+# - 11+ URLs: Deploy 7 agents or phased approach
+
+# STEP 5: Aggregate and present
+# Synthesize findings: installation, concepts, API, examples
+```
+
+## Examples
+
+**Astro framework:**
+```bash
+# Execute scripts (no manual URL construction)
+node scripts/detect-topic.js "Documentation for Astro"
+# {"isTopicSpecific": false}
+
+node scripts/fetch-docs.js "Documentation for Astro"
+# Script fetches: context7.com/withastro/astro/llms.txt
+# Returns: llms.txt with 8 URLs
+
+node scripts/analyze-llms-txt.js < llms.txt
+# {totalUrls: 8, distribution: "3-agents", grouped: {...}}
+
+# Deploy 3 Explorer agents as recommended:
+# Agent 1: Getting started, installation, setup
+# Agent 2: Core concepts, components, layouts
+# Agent 3: Configuration, API reference
+
+# Aggregate and present comprehensive report
+```
+
+## Agent Distribution
+
+**1-3 URLs:** Single agent
+**4-10 URLs:** 3-5 agents (2-3 URLs each)
+**11-20 URLs:** 7 agents (balanced)
+**21+ URLs:** Two-phase (critical first, then important)
+
+## Known Libraries
+
+- Next.js: `vercel/next.js`
+- Astro: `withastro/astro`
+- Remix: `remix-run/remix`
+- shadcn/ui: `shadcn-ui/ui`
+
+## Fallback
+
+Scripts handle fallback automatically:
+1. `fetch-docs.js` tries context7.com
+2. If 404, script suggests WebSearch for llms.txt
+3. If still unavailable: [Repository Analysis](./repo-analysis.md)

package/templates/repo/.github/skills/docs-seeker/workflows/repo-analysis.md

@@ -0,0 +1,91 @@
+# Repository Analysis (No llms.txt)
+
+**Use when:** llms.txt not available on context7.com or official site
+
+**Speed:** ⚡⚡⚡ Slower (5-10min)
+**Token usage:** 🔴 High
+**Accuracy:** 🔍 Code-based
+
+## When to Use
+
+- Library not on context7.com
+- No llms.txt on official site
+- Need to analyze code structure
+- Documentation incomplete
+
+## Workflow
+
+```
+1. Find repository
+   → WebSearch: "[library] github repository"
+   → Verify: Official, active, has docs/
+
+2. Clone repository
+   → Bash: git clone [repo-url] /tmp/docs-analysis
+   → Optional: checkout specific version/tag
+
+3. Install Repomix (if needed)
+   → Bash: npm install -g repomix
+
+4. Pack repository
+   → Bash: cd /tmp/docs-analysis && repomix --output repomix-output.xml
+   → Repomix creates AI-friendly single file
+
+5. Read packed file
+   → Read: /tmp/docs-analysis/repomix-output.xml
+   → Extract: README, docs/, examples/, API files
+
+6. Analyze structure
+   → Identify: Documentation sections
+   → Extract: Installation, usage, API, examples
+   → Note: Code patterns, best practices
+
+7. Present findings
+   → Source: Repository analysis
+   → Caveat: Based on code, not official docs
+   → Include: Repository health (stars, activity)
+```
+
+## Example
+
+**Obscure library without llms.txt:**
+```bash
+# 1. Find
+WebSearch: "MyLibrary github repository"
+# Found: https://github.com/org/mylibrary
+
+# 2. Clone
+git clone https://github.com/org/mylibrary /tmp/docs-analysis
+
+# 3. Pack with Repomix
+cd /tmp/docs-analysis
+repomix --output repomix-output.xml
+
+# 4. Read
+Read: /tmp/docs-analysis/repomix-output.xml
+# Single XML file with entire codebase
+
+# 5. Extract documentation
+- README.md: Installation, overview
+- docs/: Usage guides, API reference
+- examples/: Code samples
+- src/: Implementation patterns
+
+# 6. Present
+Source: Repository analysis (no llms.txt)
+Health: 1.2K stars, active
+```
+
+## Repomix Benefits
+
+✅ Entire repo in single file
+✅ Preserves directory structure
+✅ AI-optimized format
+✅ Includes metadata
+
+## Alternative
+
+If no GitHub repo exists:
+→ Deploy multiple Researcher agents
+→ Gather: Official site, blog posts, tutorials, Stack Overflow
+→ Note: Quality varies, cross-reference sources

package/templates/repo/.github/skills/docs-seeker/workflows/topic-search.md

@@ -0,0 +1,77 @@
+# Topic-Specific Documentation Search
+
+**Use when:** User asks about specific feature/component/concept
+
+**Speed:** ⚡ Fastest (10-15s)
+**Token usage:** 🟢 Minimal
+**Accuracy:** 🎯 Highly targeted
+
+## Trigger Patterns
+
+- "How do I use [FEATURE] in [LIBRARY]?"
+- "[LIBRARY] [COMPONENT] documentation"
+- "Implement [FEATURE] with [LIBRARY]"
+- "[LIBRARY] [CONCEPT] guide"
+
+## Workflow (Script-First)
+
+```bash
+# STEP 1: Execute detect-topic.js script
+node scripts/detect-topic.js "<user query>"
+# Returns: {"topic": "X", "library": "Y", "isTopicSpecific": true}
+
+# STEP 2: Execute fetch-docs.js script (handles URL construction automatically)
+node scripts/fetch-docs.js "<user query>"
+# Script constructs: context7.com/{library}/llms.txt?topic={topic}
+# Script handles fallback if topic URL fails
+# Returns: llms.txt content with 1-5 URLs
+
+# STEP 3: Process results based on URL count
+# - 1-3 URLs: Read directly with WebFetch tool
+# - 4-5 URLs: Deploy 2-3 Explorer agents in parallel
+
+# STEP 4: Present findings
+# Focus on specific feature: installation, usage, examples
+```
+
+## Examples
+
+**shadcn date picker:**
+```bash
+# Execute script (automatic URL construction)
+node scripts/detect-topic.js "How do I use date picker in shadcn?"
+# {"topic": "date", "library": "shadcn/ui", "isTopicSpecific": true}
+
+node scripts/fetch-docs.js "How do I use date picker in shadcn?"
+# Script fetches: context7.com/shadcn-ui/ui/llms.txt?topic=date
+# Returns: 2-3 date-specific URLs
+
+# Read URLs directly with WebFetch
+# Present date picker documentation
+```
+
+**Next.js caching:**
+```bash
+# Execute scripts (no manual URL needed)
+node scripts/detect-topic.js "Next.js caching strategies"
+# {"topic": "cache", "library": "next.js", "isTopicSpecific": true}
+
+node scripts/fetch-docs.js "Next.js caching strategies"
+# Script fetches: context7.com/vercel/next.js/llms.txt?topic=cache
+# Returns: 3-4 URLs
+
+# Process URLs via 2 Explorer agents
+# Present caching strategies
+```
+
+## Benefits
+
+✅ 10x faster than full docs
+✅ No filtering needed
+✅ Minimal context load
+✅ Best user experience
+
+## Fallback
+
+If topic URL returns 404:
+→ Fallback to [General Library Search](./library-search.md)

package/templates/repo/.github/skills/fix/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: fix
+description: ALWAYS activate this skill before fixing ANY bug, error, test failure, CI/CD issue, type error, lint, log error, UI issue, code problem.
+---
+
+# Fixing
+
+Unified skill for fixing issues of any complexity with intelligent routing.
+
+## Arguments
+
+- `--auto` - Activate autonomous mode (**default**)
+- `--review` - Activate human-in-the-loop review mode
+- `--quick` - Activate quick mode
+
+## Workflow
+
+### Step 1: Mode Selection
+
+**First action:** If there is no "auto" keyword in the request, ask the user directly to choose a workflow mode (then wait for response):
+
+| Option | Recommend When | Behavior |
+|--------|----------------|----------|
+| **Autonomous** (default) | Simple/moderate issues | Auto-approve if score >= 9.5 & 0 critical |
+| **Human-in-the-loop Review** | Critical/production code | Pause for approval at each step |
+| **Quick** | Type errors, lint, trivial bugs | Fast debug → fix → review cycle |
+
+See `references/mode-selection.md` for question format.
+
+### Step 2: Debug
+
+- Activate `debug` skill.
+- Guess all possible root causes.
+- Search in parallel to verify each hypothesis.
+- Create report with all findings for the next step.
+
+### Step 3: Complexity Assessment & Fix Implementation
+
+Classify before routing. See `references/complexity-assessment.md`.
+
+| Level | Indicators | Workflow |
+|-------|------------|----------|
+| **Simple** | Single file, clear error, type/lint | `references/workflow-quick.md` |
+| **Moderate** | Multi-file, root cause unclear | `references/workflow-standard.md` |
+| **Complex** | System-wide, architecture impact | `references/workflow-deep.md` |
+| **Parallel** | 2+ independent issues | Parallel `fullstack-developer` agents |
+
+### Step 4: Fix Verification & Prevent Future Issues
+
+- Read and analyze all the implemented changes.
+- Search in parallel to find possible related code for verification.
+- Make sure these fixes don't break other parts of the codebase.
+- Prevent future issues by adding comprehensive validation.
+
+### Step 5: Finalize
+
+- Report summary to user with confidence level/score, all the changes and related files.
+- Ask to commit via `git-manager` agent and update docs if needed via `docs-manager` agent (in parallel).
+
+---
+
+## IMPORTANT: Skill/Agent Activation Matrix
+
+See `references/skill-activation-matrix.md` for complete matrix.
+
+**Always activate:** `debug` (all workflows)
+**Conditional:** `problem-solving`, `sequential-thinking`, `brainstorming`, `context-engineering`
+**Agents:** `debugger`, `researcher`, `planner`, `code-reviewer`, `tester`
+**Parallel:** Multiple parallel searches for scouting, terminal commands for verification
+
+## Output Format
+
+Unified step markers:
+```
+✓ Step 0: [Mode] selected - [Complexity] detected
+✓ Step 1: Root cause identified - [summary]
+✓ Step 2: Fix implemented - [N] files changed
+✓ Step 3: Tests [X/X passed]
+✓ Step 4: Review [score]/10 - [status]
+✓ Step 5: Complete - [action taken]
+```
+
+## References
+
+Load as needed:
+- `references/mode-selection.md` - Mode selection question format
+- `references/complexity-assessment.md` - Classification criteria
+- `references/workflow-quick.md` - Quick: debug → fix → review
+- `references/workflow-standard.md` - Standard: full pipeline
+- `references/workflow-deep.md` - Deep: research + brainstorm + plan
+- `references/review-cycle.md` - Review logic (autonomous vs HITL)
+- `references/skill-activation-matrix.md` - When to activate each skill
+- `references/parallel-exploration.md` - Parallel search and execution patterns
+
+**Specialized Workflows:**
+- `references/workflow-ci.md` - GitHub Actions/CI failures
+- `references/workflow-logs.md` - Application log analysis
+- `references/workflow-test.md` - Test suite failures
+- `references/workflow-types.md` - TypeScript type errors
+- `references/workflow-ui.md` - Visual/UI issues (requires design skills)

package/templates/repo/.github/skills/fix/references/complexity-assessment.md

@@ -0,0 +1,61 @@
+# Complexity Assessment
+
+Classify issue complexity before routing to workflow.
+
+## Classification Criteria
+
+### Simple (→ workflow-quick.md)
+
+**Indicators:**
+- Single file affected
+- Clear error message (type error, syntax, lint)
+- Keywords: `type`, `typescript`, `tsc`, `lint`, `eslint`, `syntax`
+- Obvious fix location
+- No investigation needed
+
+**Examples:**
+- "Fix type error in auth.ts"
+- "ESLint errors after upgrade"
+- "Syntax error in config file"
+
+### Moderate (→ workflow-standard.md)
+
+**Indicators:**
+- 2-5 files affected
+- Root cause unclear but localized
+- Needs debugging investigation
+- Keywords: `bug`, `broken`, `not working`, `fails sometimes`
+- Test failures with unclear cause
+
+**Examples:**
+- "Login sometimes fails"
+- "API returns wrong data"
+- "Component not rendering correctly"
+
+### Complex (→ workflow-deep.md)
+
+**Indicators:**
+- System-wide impact (5+ files)
+- Architecture decision needed
+- Research required for solution
+- Keywords: `architecture`, `refactor`, `system-wide`, `design issue`
+- Performance/security vulnerabilities
+- Multiple interacting components
+
+**Examples:**
+- "Memory leak in production"
+- "Database deadlocks under load"
+- "Security vulnerability in auth flow"
+
+### Parallel (→ multiple fullstack-developer agents)
+
+**Indicators:**
+- 2+ independent issues mentioned
+- Issues in different areas (frontend + backend, auth + payments)
+- No dependencies between issues
+- Keywords: list of issues, "and", "also", multiple error types
+
+**Examples:**
+- "Fix type errors AND update UI styling"
+- "Auth bug + payment integration issue"
+- "3 different test failures in unrelated modules"

package/templates/repo/.github/skills/fix/references/mode-selection.md

@@ -0,0 +1,30 @@
+# Mode Selection
+
+Ask the user at start of fixing workflow to choose a mode. Present the question directly in your response, then stop and wait for their answer.
+
+## Question Format
+
+Ask the user:
+
+> **Fix Mode:** How should I handle the fix workflow?
+>
+> 1. **Autonomous (Recommended)** — Auto-approve if quality high, only ask when stuck
+> 2. **Human-in-the-loop** — Pause for approval at each major step
+> 3. **Quick fix** — Fast debug-fix-review cycle for simple issues
+
+## Mode Recommendations
+
+| Issue Type | Recommended Mode |
+|------------|------------------|
+| Type errors, lint errors | Quick |
+| Single file bugs | Quick or Autonomous |
+| Multi-file, unclear root cause | Autonomous |
+| Production/critical code | Human-in-the-loop |
+| System-wide/architecture | Human-in-the-loop |
+| Security vulnerabilities | Human-in-the-loop |
+
+## Skip Mode Selection When
+
+- Issue is clearly trivial (type error keyword detected) → default Quick
+- User explicitly specified mode in prompt
+- Previous context already established mode

package/templates/repo/.github/skills/fix/references/parallel-exploration.md

@@ -0,0 +1,77 @@
+# Parallel Exploration
+
+Patterns for launching multiple agents in parallel to scout codebase and verify implementation.
+
+## Parallel Exploration (Scouting)
+
+Launch multiple `Explore` agents simultaneously when needing to find:
+- Related files across different areas
+- Similar implementations/patterns
+- Dependencies and usage
+
+**Pattern:**
+```
+Task(agent_type="Explore", prompt="Find [X] in [area1]", description="Scout area1")
+Task(agent_type="Explore", prompt="Find [Y] in [area2]", description="Scout area2")
+Task(agent_type="Explore", prompt="Find [Z] in [area3]", description="Scout area3")
+```
+
+**Example - Multi-area scouting:**
+```
+// Launch in SINGLE message with multiple Task calls:
+Task("Explore", "Find auth-related files in src/", "Scout auth")
+Task("Explore", "Find API routes handling users", "Scout API")
+Task("Explore", "Find test files for auth module", "Scout tests")
+```
+
+## Parallel Verification (Bash)
+
+Launch multiple `Bash` agents to verify implementation from different angles.
+
+**Pattern:**
+```
+Task(agent_type="Bash", prompt="Run [command1]", description="Verify X")
+Task(agent_type="Bash", prompt="Run [command2]", description="Verify Y")
+```
+
+**Example - Multi-verification:**
+```
+// Launch in SINGLE message:
+Task("Bash", "Run typecheck: bun run typecheck", "Verify types")
+Task("Bash", "Run lint: bun run lint", "Verify lint")
+Task("Bash", "Run build: bun run build", "Verify build")
+```
+
+## When to Use Parallel
+
+| Scenario | Parallel Strategy |
+|----------|-------------------|
+| Root cause unclear, multiple suspects | 2-3 Explore agents on different areas |
+| Multi-module fix | Explore each module in parallel |
+| After implementation | Bash agents for typecheck + lint + build |
+| Before commit | Bash agents for test + build + lint |
+
+## Combining Explore + Bash
+
+**Step 1:** Parallel Explore to scout
+**Step 2:** Sequential implementation
+**Step 3:** Parallel Bash to verify
+
+```
+// Scout phase - parallel
+Task("Explore", "Find payment handlers", "Scout payments")
+Task("Explore", "Find order processors", "Scout orders")
+
+// Wait for results, implement fix
+
+// Verify phase - parallel
+Task("Bash", "Run tests: bun test", "Run tests")
+Task("Bash", "Run typecheck", "Check types")
+Task("Bash", "Run build", "Verify build")
+```
+
+## Resource Limits
+
+- Max 3 parallel agents recommended (system resources)
+- Each agent has 200K token context limit
+- Keep prompts concise to avoid context bloat

package/templates/repo/.github/skills/fix/references/review-cycle.md

@@ -0,0 +1,77 @@
+# Review Cycle
+
+Mode-aware review handling for code-reviewer results.
+
+## Autonomous Mode
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings, suggestions
+
+  2. IF score >= 9.5 AND critical_count == 0:
+     → Output: "✓ Review [score]/10 - Auto-approved"
+     → PROCEED to next step
+
+  3. ELSE IF critical_count > 0 AND cycle < 3:
+     → Output: "⚙ Auto-fixing [N] critical issues (cycle [cycle+1]/3)"
+     → Fix critical issues
+     → Re-run tests
+     → cycle++, GOTO LOOP
+
+  4. ELSE IF cycle >= 3:
+     → ESCALATE to user directly in response
+     → Display findings
+     → Ask: "Fix manually" / "Approve anyway" / "Abort" — wait for response
+
+  5. ELSE (score < 9.5, no critical):
+     → Output: "✓ Review [score]/10 - Approved with [N] warnings"
+     → PROCEED (warnings logged, not blocking)
+```
+
+## Human-in-the-Loop Mode
+
+```
+ALWAYS:
+  1. Run code-reviewer → score, critical_count, warnings, suggestions
+
+  2. Display findings:
+     ┌─────────────────────────────────────┐
+     │ Review: [score]/10                  │
+     ├─────────────────────────────────────┤
+     │ Critical ([N]): [list]              │
+     │ Warnings ([N]): [list]              │
+     │ Suggestions ([N]): [list]           │
+     └─────────────────────────────────────┘
+
+  3. Ask user directly in response, then wait for answer:
+     IF critical_count > 0:
+       - "Fix critical issues"
+       - "Fix all issues"
+       - "Approve anyway"
+       - "Abort"
+     ELSE:
+       - "Approve"
+       - "Fix warnings/suggestions"
+       - "Abort"
+
+  4. Handle response:
+     - Fix → implement, re-test, re-review (max 3 cycles)
+     - Approve → proceed
+     - Abort → stop workflow
+```
+
+## Quick Mode Review
+
+Uses same logic as Autonomous but:
+- Lower threshold: score >= 8.5 acceptable
+- Only 1 auto-fix cycle before escalate
+- Focus on: correctness, security, no regressions
+
+## Critical Issues (Always Block)
+
+- Security vulnerabilities (XSS, SQL injection, OWASP)
+- Performance bottlenecks (O(n²) when O(n) possible)
+- Architectural violations
+- Data loss risks
+- Breaking changes without migration