cokit-cli 1.0.8 → 1.2.0

package/skills/repomix/scripts/repomix_batch.py

@@ -0,0 +1,455 @@
+#!/usr/bin/env python3
+"""
+Batch process multiple repositories using Repomix.
+
+This script processes multiple repositories (local or remote) using the repomix CLI tool.
+Supports configuration through environment variables loaded from multiple .env file locations.
+"""
+
+import os
+import sys
+import subprocess
+import json
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass
+import argparse
+
+
+@dataclass
+class RepomixConfig:
+    """Configuration for repomix execution."""
+    style: str = "xml"
+    output_dir: str = "repomix-output"
+    remove_comments: bool = False
+    include_pattern: Optional[str] = None
+    ignore_pattern: Optional[str] = None
+    no_security_check: bool = False
+    verbose: bool = False
+
+
+class EnvLoader:
+    """Load environment variables from multiple .env file locations."""
+
+    @staticmethod
+    def load_env_files() -> Dict[str, str]:
+        """
+        Load environment variables from .env files in order of precedence.
+
+        Order: process.env > skill/.env > skills/.env > .copilot/.env
+
+        Returns:
+            Dictionary of environment variables
+        """
+        env_vars = {}
+        script_dir = Path(__file__).parent.resolve()
+
+        # Define search paths in reverse order (lowest to highest priority)
+        search_paths = [
+            script_dir.parent.parent.parent / ".env",  # .copilot/.env
+            script_dir.parent.parent / ".env",          # skills/.env
+            script_dir.parent / ".env",                 # skill/.env (repomix/.env)
+        ]
+
+        # Load from files (lower priority first)
+        for env_path in search_paths:
+            if env_path.exists():
+                env_vars.update(EnvLoader._parse_env_file(env_path))
+
+        # Override with process environment (highest priority)
+        env_vars.update(os.environ)
+
+        return env_vars
+
+    @staticmethod
+    def _parse_env_file(path: Path) -> Dict[str, str]:
+        """
+        Parse a .env file and return key-value pairs.
+
+        Args:
+            path: Path to .env file
+
+        Returns:
+            Dictionary of environment variables
+        """
+        env_vars = {}
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    # Skip comments and empty lines
+                    if not line or line.startswith('#'):
+                        continue
+                    # Parse KEY=VALUE
+                    if '=' in line:
+                        key, value = line.split('=', 1)
+                        key = key.strip()
+                        value = value.strip()
+                        # Remove quotes if present
+                        if value.startswith('"') and value.endswith('"'):
+                            value = value[1:-1]
+                        elif value.startswith("'") and value.endswith("'"):
+                            value = value[1:-1]
+                        env_vars[key] = value
+        except Exception as e:
+            print(f"Warning: Failed to parse {path}: {e}", file=sys.stderr)
+
+        return env_vars
+
+
+class RepomixBatchProcessor:
+    """Process multiple repositories with repomix."""
+
+    def __init__(self, config: RepomixConfig):
+        """
+        Initialize batch processor.
+
+        Args:
+            config: Repomix configuration
+        """
+        self.config = config
+        self.env_vars = EnvLoader.load_env_files()
+
+    def check_repomix_installed(self) -> bool:
+        """
+        Check if repomix is installed and accessible.
+
+        Returns:
+            True if repomix is installed, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                ["repomix", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                env=self.env_vars
+            )
+            return result.returncode == 0
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    def process_repository(
+        self,
+        repo_path: str,
+        output_name: Optional[str] = None,
+        is_remote: bool = False
+    ) -> Tuple[bool, str]:
+        """
+        Process a single repository with repomix.
+
+        Args:
+            repo_path: Path to local repository or remote repository URL
+            output_name: Custom output filename (optional)
+            is_remote: Whether repo_path is a remote URL
+
+        Returns:
+            Tuple of (success, message)
+        """
+        # Create output directory if it doesn't exist
+        output_dir = Path(self.config.output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Determine output filename
+        if output_name:
+            output_file = output_dir / output_name
+        else:
+            if is_remote:
+                # Extract repo name from URL
+                repo_name = repo_path.rstrip('/').split('/')[-1]
+            else:
+                repo_name = Path(repo_path).name
+
+            extension = self._get_extension(self.config.style)
+            output_file = output_dir / f"{repo_name}-output.{extension}"
+
+        # Build repomix command
+        cmd = self._build_command(repo_path, output_file, is_remote)
+
+        if self.config.verbose:
+            print(f"Executing: {' '.join(cmd)}")
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minute timeout
+                env=self.env_vars
+            )
+
+            if result.returncode == 0:
+                return True, f"Successfully processed {repo_path} -> {output_file}"
+            else:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                return False, f"Failed to process {repo_path}: {error_msg}"
+
+        except subprocess.TimeoutExpired:
+            return False, f"Timeout processing {repo_path} (exceeded 5 minutes)"
+        except Exception as e:
+            return False, f"Error processing {repo_path}: {str(e)}"
+
+    def _build_command(
+        self,
+        repo_path: str,
+        output_file: Path,
+        is_remote: bool
+    ) -> List[str]:
+        """
+        Build repomix command with configuration options.
+
+        Args:
+            repo_path: Path to repository
+            output_file: Output file path
+            is_remote: Whether this is a remote repository
+
+        Returns:
+            Command as list of strings
+        """
+        cmd = ["npx" if is_remote else "repomix"]
+
+        if is_remote:
+            cmd.extend(["repomix", "--remote", repo_path])
+        else:
+            cmd.append(repo_path)
+
+        # Add configuration options
+        cmd.extend(["--style", self.config.style])
+        cmd.extend(["-o", str(output_file)])
+
+        if self.config.remove_comments:
+            cmd.append("--remove-comments")
+
+        if self.config.include_pattern:
+            cmd.extend(["--include", self.config.include_pattern])
+
+        if self.config.ignore_pattern:
+            cmd.extend(["-i", self.config.ignore_pattern])
+
+        if self.config.no_security_check:
+            cmd.append("--no-security-check")
+
+        if self.config.verbose:
+            cmd.append("--verbose")
+
+        return cmd
+
+    @staticmethod
+    def _get_extension(style: str) -> str:
+        """
+        Get file extension for output style.
+
+        Args:
+            style: Output style (xml, markdown, json, plain)
+
+        Returns:
+            File extension
+        """
+        extensions = {
+            "xml": "xml",
+            "markdown": "md",
+            "json": "json",
+            "plain": "txt"
+        }
+        return extensions.get(style, "xml")
+
+    def process_batch(
+        self,
+        repositories: List[Dict[str, str]]
+    ) -> Dict[str, List[str]]:
+        """
+        Process multiple repositories.
+
+        Args:
+            repositories: List of repository configurations
+                Each dict should contain:
+                - 'path': Repository path or URL
+                - 'output': Optional output filename
+                - 'remote': Optional boolean for remote repos
+
+        Returns:
+            Dictionary with 'success' and 'failed' lists
+        """
+        results = {"success": [], "failed": []}
+
+        for repo in repositories:
+            repo_path = repo.get("path")
+            if not repo_path:
+                results["failed"].append("Missing 'path' in repository config")
+                continue
+
+            output_name = repo.get("output")
+            is_remote = repo.get("remote", False)
+
+            success, message = self.process_repository(
+                repo_path,
+                output_name,
+                is_remote
+            )
+
+            if success:
+                results["success"].append(message)
+            else:
+                results["failed"].append(message)
+
+            print(message)
+
+        return results
+
+
+def load_repositories_from_file(file_path: str) -> List[Dict[str, str]]:
+    """
+    Load repository configurations from JSON file.
+
+    Expected format:
+    [
+        {"path": "/path/to/repo", "output": "custom.xml"},
+        {"path": "owner/repo", "remote": true},
+        ...
+    ]
+
+    Args:
+        file_path: Path to JSON file
+
+    Returns:
+        List of repository configurations
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            if isinstance(data, list):
+                return data
+            else:
+                print(f"Error: Expected array in {file_path}", file=sys.stderr)
+                return []
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in {file_path}: {e}", file=sys.stderr)
+        return []
+    except Exception as e:
+        print(f"Error: Failed to read {file_path}: {e}", file=sys.stderr)
+        return []
+
+
+def main():
+    """Main entry point for the script."""
+    parser = argparse.ArgumentParser(
+        description="Batch process multiple repositories with repomix"
+    )
+
+    # Input options
+    parser.add_argument(
+        "repos",
+        nargs="*",
+        help="Repository paths or URLs to process"
+    )
+    parser.add_argument(
+        "-f", "--file",
+        help="JSON file containing repository configurations"
+    )
+
+    # Output options
+    parser.add_argument(
+        "--style",
+        choices=["xml", "markdown", "json", "plain"],
+        default="xml",
+        help="Output format (default: xml)"
+    )
+    parser.add_argument(
+        "-o", "--output-dir",
+        default="repomix-output",
+        help="Output directory (default: repomix-output)"
+    )
+
+    # Processing options
+    parser.add_argument(
+        "--remove-comments",
+        action="store_true",
+        help="Remove comments from source files"
+    )
+    parser.add_argument(
+        "--include",
+        help="Include pattern (glob)"
+    )
+    parser.add_argument(
+        "--ignore",
+        help="Ignore pattern (glob)"
+    )
+    parser.add_argument(
+        "--no-security-check",
+        action="store_true",
+        help="Disable security checks"
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Verbose output"
+    )
+    parser.add_argument(
+        "--remote",
+        action="store_true",
+        help="Treat all repos as remote URLs"
+    )
+
+    args = parser.parse_args()
+
+    # Create configuration
+    config = RepomixConfig(
+        style=args.style,
+        output_dir=args.output_dir,
+        remove_comments=args.remove_comments,
+        include_pattern=args.include,
+        ignore_pattern=args.ignore,
+        no_security_check=args.no_security_check,
+        verbose=args.verbose
+    )
+
+    # Initialize processor
+    processor = RepomixBatchProcessor(config)
+
+    # Check if repomix is installed
+    if not processor.check_repomix_installed():
+        print("Error: repomix is not installed or not in PATH", file=sys.stderr)
+        print("Install with: npm install -g repomix", file=sys.stderr)
+        return 1
+
+    # Collect repositories to process
+    repositories = []
+
+    # Load from file if specified
+    if args.file:
+        repositories.extend(load_repositories_from_file(args.file))
+
+    # Add command line repositories
+    if args.repos:
+        for repo_path in args.repos:
+            repositories.append({
+                "path": repo_path,
+                "remote": args.remote
+            })
+
+    # Validate we have repositories to process
+    if not repositories:
+        print("Error: No repositories specified", file=sys.stderr)
+        print("Use: repomix_batch.py <repo1> <repo2> ...", file=sys.stderr)
+        print("Or: repomix_batch.py -f repos.json", file=sys.stderr)
+        return 1
+
+    # Process batch
+    print(f"Processing {len(repositories)} repositories...")
+    results = processor.process_batch(repositories)
+
+    # Print summary
+    print("\n" + "=" * 50)
+    print(f"Success: {len(results['success'])}")
+    print(f"Failed: {len(results['failed'])}")
+
+    if results['failed']:
+        print("\nFailed repositories:")
+        for failure in results['failed']:
+            print(f"  - {failure}")
+
+    return 0 if not results['failed'] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/research/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: research
+description: Research technical solutions, analyze architectures, gather requirements thoroughly. Use for technology evaluation, best practices research, solution design, scalability/security/maintainability analysis.
+license: MIT
+---
+
+# Research
+
+## Research Methodology
+
+Always honoring **YAGNI**, **KISS**, and **DRY** principles.
+**Be honest, be brutal, straight to the point, and be concise.**
+
+### Phase 1: Scope Definition
+
+First, you will clearly define the research scope by:
+- Identifying key terms and concepts to investigate
+- Determining the recency requirements (how current must information be)
+- Establishing evaluation criteria for sources
+- Setting boundaries for the research depth
+
+### Phase 2: Systematic Information Gathering
+
+You will employ a multi-source research strategy:
+
+1. **Search Strategy**:
+   - **Gemini Toggle**: Check `$HOME/.copilot/.ck.json` (or `~/.copilot/.ck.json`) for `skills.research.useGemini` (default: `true`). If `false`, skip Gemini and use WebSearch.
+   - **Gemini Model**: Read from `$HOME/.copilot/.ck.json`: `gemini.model` (default: `gemini-3.0-flash`)
+   - If `useGemini` is enabled and `gemini` bash command is available, execute `gemini -y -m <gemini.model> "...your search prompt..."` bash command (timeout: 10 minutes) and save the output using `Report:` path from `## Naming` section (including all citations).
+   - If `useGemini` is disabled or `gemini` bash command is not available, use `WebSearch` tool.
+   - Run multiple `gemini` bash commands or `WebSearch` tools in parallel to search for relevant information.
+   - Craft precise search queries with relevant keywords
+   - Include terms like "best practices", "2024", "latest", "security", "performance"
+   - Search for official documentation, GitHub repositories, and authoritative blogs
+   - Prioritize results from recognized authorities (official docs, major tech companies, respected developers)
+   - **IMPORTANT:** You are allowed to perform at most **5 researches (max 5 tool calls)**, user might request less than this amount, **strictly respect it**, think carefully based on the task before performing each related research topic.
+
+2. **Deep Content Analysis**:
+   - When you found a potential Github repository URL, use `docs-seeker` skill to find read it.
+   - Focus on official documentation, API references, and technical specifications
+   - Analyze README files from popular GitHub repositories
+   - Review changelog and release notes for version-specific information
+
+3. **Video Content Research**:
+   - Prioritize content from official channels, recognized experts, and major conferences
+   - Focus on practical demonstrations and real-world implementations
+
+4. **Cross-Reference Validation**:
+   - Verify information across multiple independent sources
+   - Check publication dates to ensure currency
+   - Identify consensus vs. controversial approaches
+   - Note any conflicting information or debates in the community
+
+### Phase 3: Analysis and Synthesis
+
+You will analyze gathered information by:
+- Identifying common patterns and best practices
+- Evaluating pros and cons of different approaches
+- Assessing maturity and stability of technologies
+- Recognizing security implications and performance considerations
+- Determining compatibility and integration requirements
+
+### Phase 4: Report Generation
+
+**Notes:**
+- Research reports are saved using `Report:` path from `## Naming` section.
+- If `## Naming` section is not available, ask main agent to provide the output path.
+
+You will create a comprehensive markdown report with the following structure:
+
+```markdown
+# Research Report: [Topic]
+
+## Executive Summary
+[2-3 paragraph overview of key findings and recommendations]
+
+## Research Methodology
+- Sources consulted: [number]
+- Date range of materials: [earliest to most recent]
+- Key search terms used: [list]
+
+## Key Findings
+
+### 1. Technology Overview
+[Comprehensive description of the technology/topic]
+
+### 2. Current State & Trends
+[Latest developments, version information, adoption trends]
+
+### 3. Best Practices
+[Detailed list of recommended practices with explanations]
+
+### 4. Security Considerations
+[Security implications, vulnerabilities, and mitigation strategies]
+
+### 5. Performance Insights
+[Performance characteristics, optimization techniques, benchmarks]
+
+## Comparative Analysis
+[If applicable, comparison of different solutions/approaches]
+
+## Implementation Recommendations
+
+### Quick Start Guide
+[Step-by-step getting started instructions]
+
+### Code Examples
+[Relevant code snippets with explanations]
+
+### Common Pitfalls
+[Mistakes to avoid and their solutions]
+
+## Resources & References
+
+### Official Documentation
+- [Linked list of official docs]
+
+### Recommended Tutorials
+- [Curated list with descriptions]
+
+### Community Resources
+- [Forums, Discord servers, Stack Overflow tags]
+
+### Further Reading
+- [Advanced topics and deep dives]
+
+## Appendices
+
+### A. Glossary
+[Technical terms and definitions]
+
+### B. Version Compatibility Matrix
+[If applicable]
+
+### C. Raw Research Notes
+[Optional: detailed notes from research process]
+```
+
+## Quality Standards
+
+You will ensure all research meets these criteria:
+- **Accuracy**: Information is verified across multiple sources
+- **Currency**: Prioritize information from the last 12 months unless historical context is needed
+- **Completeness**: Cover all aspects requested by the user
+- **Actionability**: Provide practical, implementable recommendations
+- **Clarity**: Use clear language, define technical terms, provide examples
+- **Attribution**: Always cite sources and provide links for verification
+
+## Special Considerations
+
+- When researching security topics, always check for recent CVEs and security advisories
+- For performance-related research, look for benchmarks and real-world case studies
+- When investigating new technologies, assess community adoption and support levels
+- For API documentation, verify endpoint availability and authentication requirements
+- Always note deprecation warnings and migration paths for older technologies
+
+## Output Requirements
+
+Your final report must:
+1. Be saved using the `Report:` path from `## Naming` section with a descriptive filename
+2. Include a timestamp of when the research was conducted
+3. Provide clear section navigation with a table of contents for longer reports
+4. Use code blocks with appropriate syntax highlighting
+5. Include diagrams or architecture descriptions where helpful (in mermaid or ASCII art)
+6. Conclude with specific, actionable next steps
+
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+**Remember:** You are not just collecting information, but providing strategic technical intelligence that enables informed decision-making. Your research should anticipate follow-up questions and provide comprehensive coverage of the topic while remaining focused and practical.

package/skills/scout/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: scout
+description: Fast codebase scouting using parallel agents. Use for file discovery, task context gathering, quick searches across directories. Supports internal (Explore) and external (Gemini/OpenCode) agents.
+version: 1.0.0
+---
+
+# Scout
+
+Fast, token-efficient codebase scouting using parallel agents to find files needed for tasks.
+
+## Arguments
+- Default: Scout using built-in Explore subagents in parallel (`./references/internal-scouting.md`)
+- `ext`: Scout using external Gemini/OpenCode CLI tools in parallel (`./references/external-scouting.md`)
+
+## When to Use
+
+- Beginning work on feature spanning multiple directories
+- User mentions needing to "find", "locate", or "search for" files
+- Starting debugging session requiring file relationships understanding
+- User asks about project structure or where functionality lives
+- Before changes that might affect multiple codebase parts
+
+## Quick Start
+
+1. Analyze user prompt to identify search targets
+2. Use a wide range of Grep and Glob patterns to find relevant files and estimate scale of the codebase
+3. Spawn parallel agents with divided directories
+4. Collect results into concise report
+
+## Configuration
+
+Read from `$HOME/.copilot/.ck.json`:
+- `gemini.model` - Gemini model (default: `gemini-3.0-flash`)
+
+## Workflow
+
+### 1. Analyze Task
+- Parse user prompt for search targets
+- Identify key directories, patterns, file types, lines of code
+- Determine optimal SCALE value of subagents to spawn
+
+### 2. Divide and Conquer
+- Split codebase into logical segments per agent
+- Assign each agent specific directories or patterns
+- Ensure no overlap, maximize coverage
+
+### 3. Spawn Parallel Agents
+Load appropriate reference based on decision tree:
+- **Internal (Default):** `references/internal-scouting.md` (Explore subagents)
+- **External:** `references/external-scouting.md` (Gemini/OpenCode)
+
+**Notes:**
+- Prompt detailed instructions for each subagent with exact directories or files it should read
+- Remember that each subagent has less than 200K tokens of context window
+- Amount of subagents to-be-spawned depends on the current system resources available and amount of files to be scanned
+- Each subagent must return a detailed summary report to a main agent
+
+### 4. Collect Results
+- Timeout: 3 minutes per agent (skip non-responders)
+- Aggregate findings into single report
+- List unresolved questions at end
+
+## Report Format
+
+```markdown
+# Scout Report
+
+## Relevant Files
+- `path/to/file.ts` - Brief description
+- ...
+
+## Unresolved Questions
+- Any gaps in findings
+```
+
+## References
+
+- `references/internal-scouting.md` - Using Explore subagents
+- `references/external-scouting.md` - Using Gemini/OpenCode CLI