anchi-kit 1.2.3 → 1.2.6

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

@@ -0,0 +1,394 @@
+#!/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/CHANGELOG.md

@@ -6,6 +6,39 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [1.2.6] - 2025-12-30
+
+### 🚑 Critical Hotfix: Skill Installation
+
+- **Missing Skills Fixed**: Updates `init` command (Enterprise level) to copy the full `skills/` directory (including implementation sources) instead of just the metadata packs. This resolves the issue where agents had no tools to run.
+
+---
+
+## [1.2.5] - 2025-12-30
+
+### 🔧 Antigravity Support
+
+- **Environment Detection**: `init` command now detects or asks whether to install for "Cursor AI" (`.cursor`) or "Antigravity" (`.antigravity`).
+- **Dynamic Source Routing**: Correctly pulls agents/skills from the platform-specific source folders based on the target environment.
+
+---
+
+## [1.2.4] - 2025-12-30
+
+### 🛠️ CLI Stability
+
+- **Readline Conflict Fixed**: Resolved issue where `uninstall` and `clean` commands would hang or error due to conflicting `readline` interfaces between `cli.js` and subcommands.
+
+---
+
+## [1.2.3] - 2025-12-30
+
+### 📦 Installation Hotfix
+
+- **Missing Packs**: Fixed `npm publish` excluding `skills/_packs` by adding explicit include rule to `package.json`.
+
+---
+
 ## [1.2.2] - 2025-12-30
 
 ### 🛡️ Security & Reliability Hardening

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anchi-kit",
-  "version": "1.2.3",
+  "version": "1.2.6",
   "description": "The Ultimate AI-Native Toolkit for Cursor & Gemini. Installs into any existing project. Includes commands, agents, skills, and architecture presets.",
   "main": "src/cli.js",
   "bin": {
@@ -41,9 +41,7 @@
     "scripts/",
     ".cursor/commands/",
     ".cursor/agents/",
-    ".cursor/skills/_packs/",
-    ".cursor/skills/*/SKILL.md",
-    ".cursor/skills/*/references/",
+    ".cursor/skills/",
     ".cursor/workflows/",
     ".cursor/agent-skill-index.yaml",
     ".cursor/failure-modes.yaml",
@@ -56,9 +54,7 @@
     ".cursor/UX_GUIDELINES.md",
     ".antigravity/commands/",
     ".antigravity/agents/",
-    ".antigravity/skills/_packs/",
-    ".antigravity/skills/*/SKILL.md",
-    ".antigravity/skills/*/references/",
+    ".antigravity/skills/",
     ".antigravity/workflows/",
     ".antigravity/agent-skill-index.yaml",
     ".antigravity/failure-modes.yaml",

package/src/cli.js

@@ -497,6 +497,7 @@ async function main() {
             break;
 
         case 'uninstall':
+            rl.close(); // Close CLI input to prevent conflict
             const { uninstall } = require('./commands/uninstall');
             await uninstall();
             break;
@@ -524,6 +525,7 @@ async function main() {
             break;
 
         case 'clean':
+            rl.close(); // Close CLI input to prevent conflict
             const { clean } = require('./commands/clean');
             await clean(process.cwd(), {
                 all: flags.includes('--all'),

package/src/commands/clean.js

@@ -8,12 +8,16 @@ const path = require('path');
 const readline = require('readline');
 const { getConfigDir } = require('../lib/configManager');
 
-const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-});
-
-function ask(question) {
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+function ask(rl, question) {
     return new Promise((resolve) => {
         rl.question(question, (answer) => {
             resolve(answer);
@@ -22,7 +26,13 @@ function ask(question) {
 }
 
 async function clean(targetDir = process.cwd(), options = {}) {
+    let rl;
     try {
+        rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+
         console.log('');
         console.log('🧹 anchi-kit Clean');
         console.log('═══════════════════════════════════════════════════════════════');
@@ -54,7 +64,7 @@ async function clean(targetDir = process.cwd(), options = {}) {
         console.log('');
 
         if (!isForce) {
-            const confirm = await ask('⚠️  Are you sure you want to delete these files? (Y/n): ');
+            const confirm = await ask(rl, '⚠️  Are you sure you want to delete these files? (Y/n): ');
             if (confirm.toLowerCase() === 'n') {
                 console.log('❌ Cancelled.');
                 return;
@@ -108,7 +118,7 @@ async function clean(targetDir = process.cwd(), options = {}) {
         console.log('');
         console.log('✨ Clean complete! Context window refreshed.');
     } finally {
-        rl.close();
+        if (rl) rl.close();
     }
 }
 

package/src/commands/init.js

@@ -103,7 +103,25 @@ async function init() {
 
     // 1. Detect Environment (Where to install?)
     let targetFolder = '.cursor'; // Default
-    if (fs.existsSync(path.join(targetPath, '.antigravity'))) targetFolder = '.antigravity';
+    let envLabel = 'Cursor AI';
+
+    if (fs.existsSync(path.join(targetPath, '.antigravity'))) {
+        targetFolder = '.antigravity';
+        envLabel = 'Antigravity (Gemini)';
+    } else if (fs.existsSync(path.join(targetPath, '.cursor'))) {
+        targetFolder = '.cursor';
+        envLabel = 'Cursor AI';
+    } else {
+        // Ask usage environment
+        const envChoice = await askChoice('Select your AI Environment:', [
+            { value: 'cursor', label: 'Cursor AI', description: 'Install to .cursor/' },
+            { value: 'antigravity', label: 'Antigravity (Gemini)', description: 'Install to .antigravity/' }
+        ]);
+        if (envChoice === 'antigravity') {
+            targetFolder = '.antigravity';
+            envLabel = 'Antigravity (Gemini)';
+        }
+    }
     
     // 2. Auto-Detect Tech Stack & Suggest Domain
     log.info('🔍 Analyzing Project...');
@@ -168,6 +186,7 @@ async function init() {
     
     console.log('');
     log.header('📦 Installation Summary');
+    log.info(`   Platform: ${envLabel}`);
     log.info(`   Brain: ${domainConfig.label}`);
     log.info(`   Level: ${selectedLevel.toUpperCase()}`);
     log.info(`   Tools: ${selectedCaps.length > 0 ? selectedCaps.join(', ') : 'None'}`);
@@ -182,7 +201,8 @@ async function init() {
 
     // Prepare Config Object
     const anchiConfig = {
-        version: '1.2.2',
+        version: '1.2.5',
+        env: envLabel,
         domain: selectedDomain,
         level: selectedLevel,
         installed_capabilities: selectedCaps,
@@ -193,18 +213,30 @@ async function init() {
     const destFolder = path.join(targetPath, targetFolder);
     if (!fs.existsSync(destFolder)) fs.mkdirSync(destFolder, { recursive: true });
 
+    // Determine Source Paths based on Platform
+    const sourceEnv = targetFolder === '.antigravity' ? '.antigravity' : '.cursor';
+
     // 1. Install Core & Domain Agents
     log.info('   🏗️ Installing Agents...');
     const destAgents = path.join(destFolder, 'agents');
     if (!fs.existsSync(destAgents)) fs.mkdirSync(destAgents);
 
-    // Always install Core Agents (Planner, Scout, Reviewer, etc from .cursor/agents)
-    // For now, we copy ALL agents from .cursor/agents as base, then overlay domain specifics
-    // Ideally we should filter, but copying all is safer for v1.2.0 compatibility
-    const baseAgentsPath = path.join(kitPath, '.cursor/agents');
-    copyDirRecursive(baseAgentsPath, destAgents);
+    // Install Core Agents
+    // Copy all agents from platform-specific source agents folder
+    const baseAgentsPath = path.join(kitPath, sourceEnv, 'agents');
+    if (fs.existsSync(baseAgentsPath)) {
+        copyDirRecursive(baseAgentsPath, destAgents);
+    } else {
+        // Fallback to .cursor if .antigravity agents missing (should not happen in dist)
+        if (sourceEnv === '.antigravity') {
+             const fallbackAgents = path.join(kitPath, '.cursor/agents');
+             if (fs.existsSync(fallbackAgents)) copyDirRecursive(fallbackAgents, destAgents);
+        }
+    }
 
     // Overlay Domain Specific Agents (e.g., mobile-developer)
+    // Domain agents are currently shared in presets/domains...
+    // Check if separate antigravity domain agents exist? Assuming shared for now.
     const domainAgentsPath = path.join(kitPath, 'presets/domains', selectedDomain, 'agents');
     if (fs.existsSync(domainAgentsPath)) {
         copyDirRecursive(domainAgentsPath, destAgents);
@@ -214,10 +246,6 @@ async function init() {
     // Overlay Capability Agents
     for (const capKey of selectedCaps) {
         const capConfig = capabilities[capKey];
-        // Check if capability has specific agents path?
-        // Currently capability agents are standard ones (e.g. data-scientist from data domain)
-        // We can source them from the domain they belong to
-        // Heuristic: If capability is 'ai-data', agents are in 'presets/domains/data/agents'
         let capSourceDomain;
         if (capKey === 'ai-data') capSourceDomain = 'data';
         if (capKey === 'mobile-client') capSourceDomain = 'mobile';
@@ -236,8 +264,8 @@ async function init() {
     const destCommands = path.join(destFolder, 'commands');
     if (!fs.existsSync(destCommands)) fs.mkdirSync(destCommands);
     
-    // Copy Core Commands
-    const baseCommandsPath = path.join(kitPath, '.cursor/commands');
+    // Copy Core Commands from platform source
+    const baseCommandsPath = path.join(kitPath, sourceEnv, 'commands');
     if (fs.existsSync(baseCommandsPath)) {
         copyDirRecursive(baseCommandsPath, destCommands);
         log.success('      + Core Commands (start, brain, etc.)');
@@ -248,11 +276,13 @@ async function init() {
     const destSkills = path.join(destFolder, 'skills');
     if (!fs.existsSync(destSkills)) fs.mkdirSync(destSkills);
 
-    // Copying Packs... (Simplified: We copy all Packs for now, orchestration filters later)
-    // Or we can copy only defaultPacks?
-    // Let's copy specific packs based on profile to be cleaner
-    const packsSource = path.join(kitPath, '.antigravity/skills/_packs'); // Where md files are
-    const destPacks = path.join(destFolder, 'skills/_packs'); // Flat structure
+    // Copying Packs... 
+    // Skills are mostly platform agnostic but stored in platform dirs in repo.
+    // We should use the platform source for packs if possible, or defaulting to .antigravity logic from before?
+    // Actually, earlier code used .antigravity/skills/_packs as SOURCE for everyone.
+    // Let's change strictly to sourceEnv.
+    const packsSource = path.join(kitPath, sourceEnv, 'skills/_packs'); 
+    const destPacks = path.join(destFolder, 'skills/_packs'); 
     if (!fs.existsSync(destPacks)) fs.mkdirSync(destPacks);
 
     // List of packs to install
@@ -287,9 +317,17 @@ async function init() {
 
     // Enterprise: Install ALL content
     if (selectedLevel === 'enterprise') {
-        copyDirRecursive(packsSource, destPacks);
-        // Clean up empty dirs if any? No need, we want full structure.
-        log.success('   ✓ All Packs (Enterprise)');
+        // Change source from packsSource (skills/_packs) to full skillsSource (skills/)
+        // NOTE: destSkills includes destPacks, so prevent double copy? 
+        // No, destPacks is inside destSkills. If we copy sourceEnv/skills/ -> destSkills/, it includes _packs.
+        
+        const fullSkillsSource = path.join(kitPath, sourceEnv, 'skills');
+        if (fs.existsSync(fullSkillsSource)) {
+            copyDirRecursive(fullSkillsSource, destSkills);
+            log.success('   ✓ All Skills & Packs (Enterprise)');
+        } else {
+             log.warn('   ⚠️ Skills source not found.');
+        }
     } else {
         // Specific Copy
         packsToInstall.forEach(packName => {