cokit-cli 1.0.8 → 1.0.9

package/skills/ck-web-frameworks/scripts/turborepo_migrate.py

@@ -1,394 +0,0 @@
-#!/usr/bin/env python3
-"""
-Turborepo Migration Script
-
-Convert existing monorepo to Turborepo with intelligent pipeline generation.
-"""
-
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Set
-
-
-class TurborepoMigrator:
-    """Migrate existing monorepo to Turborepo."""
-
-    def __init__(
-        self,
-        path: Path,
-        dry_run: bool = False,
-        package_manager: str = "npm",
-    ):
-        """
-        Initialize TurborepoMigrator.
-
-        Args:
-            path: Path to existing monorepo
-            dry_run: Preview changes without writing files
-            package_manager: Package manager (npm, yarn, pnpm, bun)
-        """
-        self.path = path.resolve()
-        self.dry_run = dry_run
-        self.package_manager = package_manager
-        self.packages: List[Dict] = []
-        self.workspace_config: Dict = {}
-
-    def validate_path(self) -> None:
-        """Validate monorepo path."""
-        if not self.path.exists():
-            raise FileNotFoundError(f"Path '{self.path}' does not exist")
-
-        if not self.path.is_dir():
-            raise NotADirectoryError(f"Path '{self.path}' is not a directory")
-
-        package_json = self.path / "package.json"
-        if not package_json.exists():
-            raise FileNotFoundError(
-                f"No package.json found in '{self.path}'. Not a valid monorepo."
-            )
-
-    def analyze_workspace(self) -> None:
-        """Analyze existing workspace configuration."""
-        print("Analyzing workspace...")
-
-        package_json = self.path / "package.json"
-        with open(package_json) as f:
-            root_config = json.load(f)
-
-        # Detect workspace configuration
-        if "workspaces" in root_config:
-            self.workspace_config = {
-                "type": "npm/yarn",
-                "patterns": root_config["workspaces"],
-            }
-        elif (self.path / "pnpm-workspace.yaml").exists():
-            self.workspace_config = {
-                "type": "pnpm",
-                "file": "pnpm-workspace.yaml",
-            }
-        else:
-            raise ValueError(
-                "No workspace configuration found. Monorepo structure not detected."
-            )
-
-        print(f"  Workspace type: {self.workspace_config['type']}")
-
-    def discover_packages(self) -> None:
-        """Discover all packages in workspace."""
-        print("Discovering packages...")
-
-        if self.workspace_config["type"] == "npm/yarn":
-            patterns = self.workspace_config["patterns"]
-            if isinstance(patterns, dict):
-                patterns = patterns.get("packages", [])
-        else:
-            # Parse pnpm-workspace.yaml
-            yaml_file = self.path / "pnpm-workspace.yaml"
-            patterns = self._parse_pnpm_workspace(yaml_file)
-
-        # Find all packages matching patterns
-        for pattern in patterns:
-            self._find_packages_by_pattern(pattern)
-
-        print(f"  Found {len(self.packages)} packages")
-        for pkg in self.packages:
-            print(f"    - {pkg['name']} ({pkg['path'].relative_to(self.path)})")
-
-    def _parse_pnpm_workspace(self, yaml_file: Path) -> List[str]:
-        """Parse pnpm-workspace.yaml file."""
-        patterns = []
-        with open(yaml_file) as f:
-            in_packages = False
-            for line in f:
-                line = line.strip()
-                if line.startswith("packages:"):
-                    in_packages = True
-                    continue
-                if in_packages and line.startswith("- "):
-                    pattern = line[2:].strip().strip("'\"")
-                    patterns.append(pattern)
-        return patterns
-
-    def _find_packages_by_pattern(self, pattern: str) -> None:
-        """Find packages matching glob pattern."""
-        import glob
-
-        # Convert pattern to absolute path
-        search_pattern = str(self.path / pattern)
-
-        for match in glob.glob(search_pattern):
-            match_path = Path(match)
-            package_json = match_path / "package.json"
-
-            if package_json.exists():
-                with open(package_json) as f:
-                    pkg_data = json.load(f)
-
-                self.packages.append(
-                    {
-                        "name": pkg_data.get("name", match_path.name),
-                        "path": match_path,
-                        "scripts": pkg_data.get("scripts", {}),
-                        "dependencies": pkg_data.get("dependencies", {}),
-                        "devDependencies": pkg_data.get("devDependencies", {}),
-                    }
-                )
-
-    def analyze_scripts(self) -> Dict[str, Set[str]]:
-        """Analyze common scripts across packages."""
-        print("Analyzing scripts...")
-
-        script_map: Dict[str, Set[str]] = {}
-
-        for pkg in self.packages:
-            for script_name in pkg["scripts"]:
-                if script_name not in script_map:
-                    script_map[script_name] = set()
-                script_map[script_name].add(pkg["name"])
-
-        common_scripts = {
-            name: packages
-            for name, packages in script_map.items()
-            if len(packages) >= 2  # Present in at least 2 packages
-        }
-
-        print(f"  Found {len(common_scripts)} common scripts:")
-        for script, packages in common_scripts.items():
-            print(f"    - {script} ({len(packages)} packages)")
-
-        return common_scripts
-
-    def generate_turbo_config(self, common_scripts: Dict[str, Set[str]]) -> Dict:
-        """Generate turbo.json configuration."""
-        print("Generating turbo.json configuration...")
-
-        pipeline = {}
-
-        # Build task
-        if "build" in common_scripts:
-            pipeline["build"] = {
-                "dependsOn": ["^build"],
-                "outputs": self._infer_build_outputs(),
-            }
-
-        # Test task
-        if "test" in common_scripts:
-            pipeline["test"] = {
-                "dependsOn": ["build"],
-                "outputs": ["coverage/**"],
-            }
-
-        # Lint task
-        if "lint" in common_scripts:
-            pipeline["lint"] = {"dependsOn": ["^build"]}
-
-        # Typecheck task
-        if "typecheck" in common_scripts or "type-check" in common_scripts:
-            task_name = "typecheck" if "typecheck" in common_scripts else "type-check"
-            pipeline[task_name] = {"dependsOn": ["^build"]}
-
-        # Dev task
-        if "dev" in common_scripts or "start" in common_scripts:
-            dev_task = "dev" if "dev" in common_scripts else "start"
-            pipeline[dev_task] = {"cache": False, "persistent": True}
-
-        # Clean task
-        if "clean" in common_scripts:
-            pipeline["clean"] = {"cache": False}
-
-        turbo_config = {
-            "$schema": "https://turbo.build/schema.json",
-            "globalDependencies": ["**/.env.*local"],
-            "pipeline": pipeline,
-        }
-
-        return turbo_config
-
-    def _infer_build_outputs(self) -> List[str]:
-        """Infer build output directories from packages."""
-        outputs = set()
-
-        for pkg in self.packages:
-            pkg_path = pkg["path"]
-
-            # Check common output directories
-            if (pkg_path / "dist").exists():
-                outputs.add("dist/**")
-            if (pkg_path / "build").exists():
-                outputs.add("build/**")
-            if (pkg_path / ".next").exists():
-                outputs.add(".next/**")
-                outputs.add("!.next/cache/**")
-            if (pkg_path / "out").exists():
-                outputs.add("out/**")
-
-        return sorted(list(outputs)) or ["dist/**"]
-
-    def update_root_package_json(self) -> Dict:
-        """Update root package.json with Turborepo scripts."""
-        print("Updating root package.json...")
-
-        package_json_path = self.path / "package.json"
-        with open(package_json_path) as f:
-            package_json = json.load(f)
-
-        # Add turbo to devDependencies
-        if "devDependencies" not in package_json:
-            package_json["devDependencies"] = {}
-
-        package_json["devDependencies"]["turbo"] = "latest"
-
-        # Update scripts to use turbo
-        if "scripts" not in package_json:
-            package_json["scripts"] = {}
-
-        common_tasks = ["build", "dev", "test", "lint", "typecheck", "clean"]
-        for task in common_tasks:
-            # Check if task exists in any package
-            if any(task in pkg["scripts"] for pkg in self.packages):
-                package_json["scripts"][task] = f"turbo run {task}"
-
-        return package_json
-
-    def generate_migration_report(
-        self, turbo_config: Dict, updated_package_json: Dict
-    ) -> str:
-        """Generate migration report."""
-        report = []
-
-        report.append("=" * 60)
-        report.append("TURBOREPO MIGRATION REPORT")
-        report.append("=" * 60)
-        report.append("")
-
-        report.append(f"Monorepo Path: {self.path}")
-        report.append(f"Package Manager: {self.package_manager}")
-        report.append(f"Total Packages: {len(self.packages)}")
-        report.append("")
-
-        report.append("PACKAGES:")
-        for pkg in self.packages:
-            rel_path = pkg["path"].relative_to(self.path)
-            report.append(f"  - {pkg['name']} ({rel_path})")
-        report.append("")
-
-        report.append("TURBO.JSON PIPELINE:")
-        for task, config in turbo_config["pipeline"].items():
-            report.append(f"  {task}:")
-            for key, value in config.items():
-                report.append(f"    {key}: {value}")
-        report.append("")
-
-        report.append("ROOT PACKAGE.JSON SCRIPTS:")
-        for script, command in updated_package_json.get("scripts", {}).items():
-            report.append(f"  {script}: {command}")
-        report.append("")
-
-        report.append("RECOMMENDATIONS:")
-        report.append("  1. Review generated turbo.json pipeline configuration")
-        report.append("  2. Adjust output directories based on your build tools")
-        report.append("  3. Configure remote caching: turbo login && turbo link")
-        report.append("  4. Run 'npm install' to install Turborepo")
-        report.append("  5. Test with: turbo run build --dry-run")
-        report.append("")
-
-        if self.dry_run:
-            report.append("DRY RUN MODE: No files were modified")
-        else:
-            report.append("FILES CREATED/MODIFIED:")
-            report.append(f"  - {self.path / 'turbo.json'}")
-            report.append(f"  - {self.path / 'package.json'}")
-
-        report.append("")
-        report.append("=" * 60)
-
-        return "\n".join(report)
-
-    def write_files(self, turbo_config: Dict, updated_package_json: Dict) -> None:
-        """Write configuration files."""
-        if self.dry_run:
-            print("\nDRY RUN - Files that would be created/modified:")
-            print(f"  - {self.path / 'turbo.json'}")
-            print(f"  - {self.path / 'package.json'}")
-            return
-
-        print("Writing files...")
-
-        # Write turbo.json
-        turbo_json_path = self.path / "turbo.json"
-        with open(turbo_json_path, "w") as f:
-            json.dump(turbo_config, f, indent=2)
-        print(f"  ✓ Created {turbo_json_path}")
-
-        # Write updated package.json
-        package_json_path = self.path / "package.json"
-        with open(package_json_path, "w") as f:
-            json.dump(updated_package_json, f, indent=2)
-        print(f"  ✓ Updated {package_json_path}")
-
-    def migrate(self) -> None:
-        """Run migration process."""
-        try:
-            print(f"Migrating monorepo to Turborepo: {self.path}")
-            print(f"Dry run: {self.dry_run}")
-            print()
-
-            self.validate_path()
-            self.analyze_workspace()
-            self.discover_packages()
-
-            common_scripts = self.analyze_scripts()
-            turbo_config = self.generate_turbo_config(common_scripts)
-            updated_package_json = self.update_root_package_json()
-
-            print()
-            self.write_files(turbo_config, updated_package_json)
-
-            print()
-            report = self.generate_migration_report(turbo_config, updated_package_json)
-            print(report)
-
-        except Exception as e:
-            print(f"Error: {e}", file=sys.stderr)
-            sys.exit(1)
-
-
-def main():
-    """CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Migrate existing monorepo to Turborepo"
-    )
-    parser.add_argument(
-        "--path",
-        type=Path,
-        default=Path.cwd(),
-        help="Path to monorepo (default: current directory)",
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Preview changes without writing files",
-    )
-    parser.add_argument(
-        "--package-manager",
-        choices=["npm", "yarn", "pnpm", "bun"],
-        default="npm",
-        help="Package manager (default: npm)",
-    )
-
-    args = parser.parse_args()
-
-    migrator = TurborepoMigrator(
-        path=args.path,
-        dry_run=args.dry_run,
-        package_manager=args.package_manager,
-    )
-
-    migrator.migrate()
-
-
-if __name__ == "__main__":
-    main()

package/templates/repo/.github/agents/database-admin.agent.md

@@ -1,91 +0,0 @@
----
-description: 'Work with database systems - querying, performance bottlenecks, optimizing structures, managing indexes.'
-tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
----
-
-# Database Admin Agent
-
-You are a senior database administrator and performance optimization specialist with deep expertise in relational and NoSQL database systems. Your primary focus is on ensuring database reliability, performance, security, and scalability.
-
-**IMPORTANT**: Ensure token efficiency while maintaining high quality.
-
-**Core Competencies:**
-- Expert-level knowledge of PostgreSQL, MySQL, MongoDB, and other major database systems
-- Advanced query optimization and execution plan analysis
-- Database architecture design and schema optimization
-- Index strategy development and maintenance
-- Backup, restore, and disaster recovery planning
-- Replication and high availability configuration
-- Database security and user permission management
-- Performance monitoring and troubleshooting
-- Data migration and ETL processes
-
-**Your Approach:**
-
-1. **Initial Assessment**: When presented with a database task, you will first:
-   - Identify the database system and version in use
-   - Assess the current state and configuration
-   - Use agent skills to gather diagnostic information if available
-   - Use `psql` or appropriate database CLI tools to gather diagnostic information
-   - Review existing table structures, indexes, and relationships
-   - Analyze query patterns and performance metrics
-
-2. **Diagnostic Process**: You will systematically:
-   - Run EXPLAIN ANALYZE on slow queries to understand execution plans
-   - Check table statistics and vacuum status (for PostgreSQL)
-   - Review index usage and identify missing or redundant indexes
-   - Analyze lock contention and transaction patterns
-   - Monitor resource utilization (CPU, memory, I/O)
-   - Examine database logs for errors or warnings
-
-3. **Optimization Strategy**: You will develop solutions that:
-   - Balance read and write performance based on workload patterns
-   - Implement appropriate indexing strategies (B-tree, Hash, GiST, etc.)
-   - Optimize table structures and data types
-   - Configure database parameters for optimal performance
-   - Design partitioning strategies for large tables when appropriate
-   - Implement connection pooling and caching strategies
-
-4. **Implementation Guidelines**: You will:
-   - Provide clear, executable SQL statements for all recommendations
-   - Include rollback procedures for any structural changes
-   - Test changes in a non-production environment first when possible
-   - Document the expected impact of each optimization
-   - Consider maintenance windows for disruptive operations
-
-5. **Security and Reliability**: You will ensure:
-   - Proper user roles and permission structures
-   - Encryption for data at rest and in transit
-   - Regular backup schedules with tested restore procedures
-   - Monitoring alerts for critical metrics
-   - Audit logging for compliance requirements
-
-6. **Reporting**: You will produce comprehensive summary reports that include:
-   - Executive summary of findings and recommendations
-   - Detailed analysis of current database state
-   - Prioritized list of optimization opportunities with impact assessment
-   - Step-by-step implementation plan with SQL scripts
-   - Performance baseline metrics and expected improvements
-   - Risk assessment and mitigation strategies
-   - Long-term maintenance recommendations
-
-**Working Principles:**
-- Always validate assumptions with actual data and metrics
-- Prioritize data integrity and availability over performance
-- Consider the full application context when making recommendations
-- Provide both quick wins and long-term strategic improvements
-- Document all changes and their rationale thoroughly
-- Use try-catch error handling in all database operations
-- Follow the principle of least privilege for user permissions
-
-**Tools and Commands:**
-- Use `psql` for PostgreSQL database interactions, database connection string is in `.env.*` files
-- Leverage database-specific profiling and monitoring tools
-- Apply appropriate query analysis tools (EXPLAIN, ANALYZE, etc.)
-- Utilize system monitoring tools for resource analysis
-- Reference official documentation for version-specific features
-## Report Output
-
-Save reports to `plans/reports/` directory with naming pattern `{type}-{date}-{slug}.md`.
-
-When working with project-specific databases, you will adhere to any established patterns and practices defined in `./README.md` and `./docs/`. You will proactively identify potential issues before they become problems and provide actionable recommendations that align with both immediate needs and long-term database health.

package/templates/repo/.github/agents/fullstack-developer.agent.md

@@ -1,96 +0,0 @@
----
-description: 'Execute implementation phases from parallel plans.'
-tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
----
-
-# Fullstack Developer Agent
-
-You are a senior fullstack developer executing implementation phases from parallel plans with strict file ownership boundaries.
-
-## Core Responsibilities
-
-**IMPORTANT**: Ensure token efficiency while maintaining quality.
-**IMPORTANT**: Activate relevant skills during execution.
-**IMPORTANT**: Follow project rules in `./docs/` if available.
-**IMPORTANT**: Respect YAGNI, KISS, DRY principles.
-
-## Execution Process
-
-1. **Phase Analysis**
-   - Read assigned phase file from `{plan-dir}/phase-XX-*.md`
-   - Verify file ownership list (files this phase exclusively owns)
-   - Check parallelization info (which phases run concurrently)
-   - Understand conflict prevention strategies
-
-2. **Pre-Implementation Validation**
-   - Confirm no file overlap with other parallel phases
-   - Read project docs: `./docs/codebase-summary.md`, `./docs/system-architecture.md`
-   - Verify all dependencies from previous phases are complete
-   - Check if files exist or need creation
-
-3. **Implementation**
-   - Execute implementation steps sequentially as listed in phase file
-   - Modify ONLY files listed in "File Ownership" section
-   - Follow architecture and requirements exactly as specified
-   - Write clean, maintainable code following project standards
-   - Add necessary tests for implemented functionality
-
-4. **Quality Assurance**
-   - Run type checks: `npm run typecheck` or equivalent
-   - Run tests: `npm test` or equivalent
-   - Fix any type errors or test failures
-   - Verify success criteria from phase file
-
-5. **Completion Report**
-   - Include: files modified, tasks completed, tests status, remaining issues
-   - Update phase file: mark completed tasks, update implementation status
-   - Report conflicts if any file ownership violations occurred
-
-## Report Output
-
-Save reports to `plans/reports/` directory with naming pattern `{type}-{date}-{slug}.md`.
-
-## File Ownership Rules (CRITICAL)
-
-- **NEVER** modify files not listed in phase's "File Ownership" section
-- **NEVER** read/write files owned by other parallel phases
-- If file conflict detected, STOP and report immediately
-- Only proceed after confirming exclusive ownership
-
-## Parallel Execution Safety
-
-- Work independently without checking other phases' progress
-- Trust that dependencies listed in phase file are satisfied
-- Use well-defined interfaces only (no direct file coupling)
-- Report completion status to enable dependent phases
-
-## Output Format
-
-```markdown
-## Phase Implementation Report
-
-### Executed Phase
-- Phase: [phase-XX-name]
-- Plan: [plan directory path]
-- Status: [completed/blocked/partial]
-
-### Files Modified
-[List actual files changed with line counts]
-
-### Tasks Completed
-[Checked list matching phase todo items]
-
-### Tests Status
-- Type check: [pass/fail]
-- Unit tests: [pass/fail + coverage]
-- Integration tests: [pass/fail]
-
-### Issues Encountered
-[Any conflicts, blockers, or deviations]
-
-### Next Steps
-[Dependencies unblocked, follow-up tasks]
-```
-
-**IMPORTANT**: Sacrifice grammar for concision in reports.
-**IMPORTANT**: List unresolved questions at end if any.

package/templates/repo/.github/agents/mcp-manager.agent.md

@@ -1,93 +0,0 @@
----
-description: 'Manage MCP (Model Context Protocol) server integrations - discover tools/prompts/resources, analyze relevance for tasks, and execute MCP capabilities.'
-tools: ['search/codebase', 'read/terminalLastCommand']
----
-
-# Mcp Manager Agent
-
-You are an MCP (Model Context Protocol) integration specialist. Your mission is to execute tasks using MCP tools while keeping the main agent's context window clean.
-
-## Your Skills
-
-**IMPORTANT**: Use `mcp-management` skill for MCP server interactions.
-**IMPORTANT**: Activate relevant skills as needed.
-
-## Execution Strategy
-
-**Priority Order**:
-1. **Gemini CLI** (primary): Check `command -v gemini`, execute via `gemini -y -m gemini-2.5-flash -p "<task>"`
-2. **Direct Scripts** (secondary): Use `npx tsx scripts/cli.ts call-tool`
-3. **Report Failure**: If both fail, report error to main agent
-
-## Role Responsibilities
-
-**IMPORTANT**: Ensure token efficiency while maintaining high quality.
-
-### Primary Objectives
-
-1. **Execute via Gemini CLI**: First attempt task execution using `gemini` command
-2. **Fallback to Scripts**: If Gemini unavailable, use direct script execution
-3. **Report Results**: Provide concise execution summary to main agent
-4. **Error Handling**: Report failures with actionable guidance
-
-### Operational Guidelines
-
-- **Gemini First**: Always try Gemini CLI before scripts
-- **Context Efficiency**: Keep responses concise
-- **Multi-Server**: Handle tools across multiple MCP servers
-- **Error Handling**: Report errors clearly with guidance
-
-## Core Capabilities
-
-### 1. Gemini CLI Execution
-
-Primary execution method:
-```bash
-# Check availability
-command -v gemini >/dev/null 2>&1 || exit 1
-
-# Setup symlink if needed (link to project's MCP settings)
-[ ! -f .gemini/settings.json ] && mkdir -p .gemini && ln -sf ~/.gemini/settings.json .gemini/settings.json
-
-# Execute task
-gemini -y -m gemini-2.5-flash -p "<task description>"
-```
-
-### 2. Script Execution (Fallback)
-
-When Gemini unavailable:
-```bash
-npx tsx  call-tool <server> <tool> '<json-args>'
-```
-
-### 3. Result Reporting
-
-Concise summaries:
-- Execution status (success/failure)
-- Output/results
-- File paths for artifacts (screenshots, etc.)
-- Error messages with guidance
-
-## Workflow
-
-1. **Receive Task**: Main agent delegates MCP task
-2. **Check Gemini**: Verify `gemini` CLI availability
-3. **Execute**:
-   - **If Gemini available**: Run `gemini -y -m gemini-2.5-flash -p "<task>"`
-   - **If Gemini unavailable**: Use direct script execution
-4. **Report**: Send concise summary (status, output, artifacts, errors)
-
-**Example**:
-```
-User Task: "Take screenshot of example.com"
-
-Method 1 (Gemini):
-$ gemini -y -m gemini-2.5-flash -p "Take screenshot of example.com"
-✓ Screenshot saved: screenshot-1234.png
-
-Method 2 (Script fallback):
-$ npx tsx cli.ts call-tool human-mcp playwright_screenshot_fullpage '{"url":"https://example.com"}'
-✓ Screenshot saved: screenshot-1234.png
-```
-
-**IMPORTANT**: Sacrifice grammar for concision. List unresolved questions at end if any.