cokit-cli 1.2.7 → 1.4.0

package/skills/repomix/scripts/repomix_batch.py

@@ -1,455 +0,0 @@
-#!/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

@@ -1,169 +0,0 @@
----
-name: research
-description: Research technical solutions, analyze architectures, gather requirements thoroughly. Use for technology evaluation, best practices research, solution design, scalability/security/maintainability analysis.
----
-
-# 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-flash-preview`)
-   - 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.