bps-kit 1.0.1 → 1.0.2

package/templates/vault/scripts/skill_search.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+skill_search.py — Find skills by keyword from installed skills
+Usage: python3 skill_search.py "your search here"
+       python3 skill_search.py "authentication"
+       python3 skill_search.py "react component animation"
+       python3 skill_search.py --list          (list all skill names)
+
+Scans SKILL.md files in each skill directory for name/description.
+Works without skills_index.json by reading SKILL.md frontmatter directly.
+"""
+import json
+import sys
+import os
+import re
+from pathlib import Path
+
+# Resolve paths relative to this script's location
+SCRIPT_DIR = Path(__file__).parent
+REPO_ROOT = SCRIPT_DIR.parent
+SKILLS_DIR = REPO_ROOT  # skills are direct children
+INDEX_FILE = REPO_ROOT / "skills_index.json"
+BUNDLES_FILE = REPO_ROOT / "data" / "bundles.json"
+CACHE_FILE = SCRIPT_DIR / ".skill_cache.json"
+
+
+def parse_skill_md(skill_dir: Path) -> dict:
+    """Extract name and description from SKILL.md frontmatter."""
+    skill_file = skill_dir / "SKILL.md"
+    if not skill_file.exists():
+        return None
+
+    try:
+        content = skill_file.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return None
+
+    name = skill_dir.name
+    description = ""
+
+    # Try YAML frontmatter: ---\nkey: value\n---
+    fm_match = re.match(r"^---\s*\n(.*?)\n---", content, re.DOTALL)
+    if fm_match:
+        frontmatter = fm_match.group(1)
+        # Extract name
+        name_match = re.search(r"^name:\s*(.+)$", frontmatter, re.MULTILINE)
+        if name_match:
+            name = name_match.group(1).strip().strip("'\"")
+        # Extract description
+        desc_match = re.search(r"^description:\s*(.+)$", frontmatter, re.MULTILINE)
+        if desc_match:
+            description = desc_match.group(1).strip().strip("'\"")
+
+    # If no description from frontmatter, grab first meaningful paragraph
+    if not description:
+        lines = content.split("\n")
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith("#") and not line.startswith("---") and len(line) > 20:
+                description = line[:200]
+                break
+
+    return {
+        "name": name,
+        "description": description,
+        "path": skill_dir.name,
+        "dir": str(skill_dir),
+    }
+
+
+def load_skills():
+    """Load skills from index file or scan directories."""
+    # Try skills_index.json first
+    if INDEX_FILE.exists():
+        try:
+            with open(INDEX_FILE, encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, list):
+                return data
+            if isinstance(data, dict) and "skills" in data:
+                return data["skills"]
+            return list(data.values())
+        except Exception:
+            pass
+
+    # Try cache (rebuilt periodically)
+    if CACHE_FILE.exists():
+        try:
+            cache_stat = CACHE_FILE.stat()
+            import time
+            # Use cache if less than 1 hour old
+            if (time.time() - cache_stat.st_mtime) < 3600:
+                with open(CACHE_FILE, encoding="utf-8") as f:
+                    return json.load(f)
+        except Exception:
+            pass
+
+    # Scan directories
+    print("🔄 Building skill index (first run may take a moment)...")
+    skills = []
+    if not SKILLS_DIR.exists():
+        print(f"❌ Skills directory not found: {SKILLS_DIR}")
+        sys.exit(1)
+
+    for item in sorted(SKILLS_DIR.iterdir()):
+        if item.is_dir() and not item.name.startswith(".") and item.name not in ("scripts", "data", "node_modules"):
+            skill = parse_skill_md(item)
+            if skill:
+                skills.append(skill)
+
+    # Cache for faster subsequent runs
+    try:
+        SCRIPT_DIR.mkdir(parents=True, exist_ok=True)
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(skills, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+    return skills
+
+
+def search(query: str, top_n: int = 10):
+    skills = load_skills()
+    terms = query.lower().split()
+
+    results = []
+    for skill in skills:
+        name = str(skill.get("name", "")).lower()
+        desc = str(skill.get("description", "")).lower()
+        path = str(skill.get("path", "")).lower()
+        full_text = f"{name} {desc} {path}"
+
+        # Score: name matches count double
+        score = sum(full_text.count(t) for t in terms)
+        score += sum(name.count(t) * 2 for t in terms)
+
+        # Bonus for exact name match
+        if query.lower() in name:
+            score += 10
+
+        if score > 0:
+            results.append((score, skill))
+
+    results.sort(key=lambda x: -x[0])
+
+    if not results:
+        print(f"\n🔍 Nenhuma skill encontrada para: '{query}'")
+        print("   Tente termos mais amplos, ex: 'auth', 'deploy', 'test', 'api'\n")
+        return
+
+    print(f"\n🎯 Top skills para '{query}':\n")
+    for score, skill in results[:top_n]:
+        path_val = skill.get("path", "")
+        name_val = skill.get("name", path_val)
+        desc_val = skill.get("description", "")
+        if len(desc_val) > 100:
+            desc_val = desc_val[:97] + "..."
+        print(f"  📌 {name_val}")
+        print(f"     Invocar: \"Use the {path_val} skill to [sua tarefa]\"")
+        if desc_val:
+            print(f"     Sobre: {desc_val}")
+        print()
+
+
+def list_all():
+    skills = load_skills()
+    print(f"\n📋 Total de skills instaladas: {len(skills)}\n")
+    for skill in skills:
+        name = skill.get("name", skill.get("path", "?"))
+        desc = skill.get("description", "")
+        if len(desc) > 80:
+            desc = desc[:77] + "..."
+        print(f"  • {name}")
+        if desc:
+            print(f"    {desc}")
+    print()
+
+
+def list_bundles():
+    if not BUNDLES_FILE.exists():
+        print("❌ bundles.json não encontrado.")
+        print(f"   Caminho esperado: {BUNDLES_FILE}")
+        return
+    with open(BUNDLES_FILE, encoding="utf-8") as f:
+        data = json.load(f)
+    bundles = data if isinstance(data, list) else data.get("bundles", [])
+    print("\n📦 Bundles Disponíveis:\n")
+    for b in bundles:
+        name = b.get("name", "?")
+        desc = b.get("description", "")
+        skills_list = b.get("skills", [])
+        print(f"  {name}")
+        if desc:
+            print(f"    {desc}")
+        if skills_list:
+            skills_preview = ", ".join(skills_list[:5])
+            if len(skills_list) > 5:
+                skills_preview += f" (+{len(skills_list)-5} mais)"
+            print(f"    Skills: {skills_preview}")
+        print()
+
+
+def rebuild_cache():
+    """Force cache rebuild."""
+    if CACHE_FILE.exists():
+        CACHE_FILE.unlink()
+    skills = load_skills()
+    print(f"✅ Cache reconstruído com {len(skills)} skills.")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Uso: python3 skill_search.py \"termos de busca\"")
+        print("     python3 skill_search.py --bundles")
+        print("     python3 skill_search.py --list")
+        print("     python3 skill_search.py --rebuild")
+        sys.exit(0)
+
+    arg = sys.argv[1]
+    if arg in ("--bundles", "-b", "bundles"):
+        list_bundles()
+    elif arg in ("--list", "-l", "list"):
+        list_all()
+    elif arg in ("--rebuild", "-r", "rebuild"):
+        rebuild_cache()
+    else:
+        query = " ".join(sys.argv[1:])
+        search(query)

package/templates/vault/senior-architect/scripts/architecture_diagram_generator.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Architecture Diagram Generator
+Automated tool for senior architect tasks
+"""
+
+import os
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional
+
+class ArchitectureDiagramGenerator:
+    """Main class for architecture diagram generator functionality"""
+    
+    def __init__(self, target_path: str, verbose: bool = False):
+        self.target_path = Path(target_path)
+        self.verbose = verbose
+        self.results = {}
+    
+    def run(self) -> Dict:
+        """Execute the main functionality"""
+        print(f"🚀 Running {self.__class__.__name__}...")
+        print(f"📁 Target: {self.target_path}")
+        
+        try:
+            self.validate_target()
+            self.analyze()
+            self.generate_report()
+            
+            print("✅ Completed successfully!")
+            return self.results
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+    
+    def validate_target(self):
+        """Validate the target path exists and is accessible"""
+        if not self.target_path.exists():
+            raise ValueError(f"Target path does not exist: {self.target_path}")
+        
+        if self.verbose:
+            print(f"✓ Target validated: {self.target_path}")
+    
+    def analyze(self):
+        """Perform the main analysis or operation"""
+        if self.verbose:
+            print("📊 Analyzing...")
+        
+        # Main logic here
+        self.results['status'] = 'success'
+        self.results['target'] = str(self.target_path)
+        self.results['findings'] = []
+        
+        # Add analysis results
+        if self.verbose:
+            print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
+    
+    def generate_report(self):
+        """Generate and display the report"""
+        print("\n" + "="*50)
+        print("REPORT")
+        print("="*50)
+        print(f"Target: {self.results.get('target')}")
+        print(f"Status: {self.results.get('status')}")
+        print(f"Findings: {len(self.results.get('findings', []))}")
+        print("="*50 + "\n")
+
+def main():
+    """Main entry point"""
+    parser = argparse.ArgumentParser(
+        description="Architecture Diagram Generator"
+    )
+    parser.add_argument(
+        'target',
+        help='Target path to analyze or process'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose output'
+    )
+    parser.add_argument(
+        '--json',
+        action='store_true',
+        help='Output results as JSON'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        help='Output file path'
+    )
+    
+    args = parser.parse_args()
+    
+    tool = ArchitectureDiagramGenerator(
+        args.target,
+        verbose=args.verbose
+    )
+    
+    results = tool.run()
+    
+    if args.json:
+        output = json.dumps(results, indent=2)
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(output)
+            print(f"Results written to {args.output}")
+        else:
+            print(output)
+
+if __name__ == '__main__':
+    main()

package/templates/vault/senior-architect/scripts/dependency_analyzer.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Dependency Analyzer
+Automated tool for senior architect tasks
+"""
+
+import os
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional
+
+class DependencyAnalyzer:
+    """Main class for dependency analyzer functionality"""
+    
+    def __init__(self, target_path: str, verbose: bool = False):
+        self.target_path = Path(target_path)
+        self.verbose = verbose
+        self.results = {}
+    
+    def run(self) -> Dict:
+        """Execute the main functionality"""
+        print(f"🚀 Running {self.__class__.__name__}...")
+        print(f"📁 Target: {self.target_path}")
+        
+        try:
+            self.validate_target()
+            self.analyze()
+            self.generate_report()
+            
+            print("✅ Completed successfully!")
+            return self.results
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+    
+    def validate_target(self):
+        """Validate the target path exists and is accessible"""
+        if not self.target_path.exists():
+            raise ValueError(f"Target path does not exist: {self.target_path}")
+        
+        if self.verbose:
+            print(f"✓ Target validated: {self.target_path}")
+    
+    def analyze(self):
+        """Perform the main analysis or operation"""
+        if self.verbose:
+            print("📊 Analyzing...")
+        
+        # Main logic here
+        self.results['status'] = 'success'
+        self.results['target'] = str(self.target_path)
+        self.results['findings'] = []
+        
+        # Add analysis results
+        if self.verbose:
+            print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
+    
+    def generate_report(self):
+        """Generate and display the report"""
+        print("\n" + "="*50)
+        print("REPORT")
+        print("="*50)
+        print(f"Target: {self.results.get('target')}")
+        print(f"Status: {self.results.get('status')}")
+        print(f"Findings: {len(self.results.get('findings', []))}")
+        print("="*50 + "\n")
+
+def main():
+    """Main entry point"""
+    parser = argparse.ArgumentParser(
+        description="Dependency Analyzer"
+    )
+    parser.add_argument(
+        'target',
+        help='Target path to analyze or process'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose output'
+    )
+    parser.add_argument(
+        '--json',
+        action='store_true',
+        help='Output results as JSON'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        help='Output file path'
+    )
+    
+    args = parser.parse_args()
+    
+    tool = DependencyAnalyzer(
+        args.target,
+        verbose=args.verbose
+    )
+    
+    results = tool.run()
+    
+    if args.json:
+        output = json.dumps(results, indent=2)
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(output)
+            print(f"Results written to {args.output}")
+        else:
+            print(output)
+
+if __name__ == '__main__':
+    main()

package/templates/vault/senior-architect/scripts/project_architect.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Project Architect
+Automated tool for senior architect tasks
+"""
+
+import os
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional
+
+class ProjectArchitect:
+    """Main class for project architect functionality"""
+    
+    def __init__(self, target_path: str, verbose: bool = False):
+        self.target_path = Path(target_path)
+        self.verbose = verbose
+        self.results = {}
+    
+    def run(self) -> Dict:
+        """Execute the main functionality"""
+        print(f"🚀 Running {self.__class__.__name__}...")
+        print(f"📁 Target: {self.target_path}")
+        
+        try:
+            self.validate_target()
+            self.analyze()
+            self.generate_report()
+            
+            print("✅ Completed successfully!")
+            return self.results
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+    
+    def validate_target(self):
+        """Validate the target path exists and is accessible"""
+        if not self.target_path.exists():
+            raise ValueError(f"Target path does not exist: {self.target_path}")
+        
+        if self.verbose:
+            print(f"✓ Target validated: {self.target_path}")
+    
+    def analyze(self):
+        """Perform the main analysis or operation"""
+        if self.verbose:
+            print("📊 Analyzing...")
+        
+        # Main logic here
+        self.results['status'] = 'success'
+        self.results['target'] = str(self.target_path)
+        self.results['findings'] = []
+        
+        # Add analysis results
+        if self.verbose:
+            print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
+    
+    def generate_report(self):
+        """Generate and display the report"""
+        print("\n" + "="*50)
+        print("REPORT")
+        print("="*50)
+        print(f"Target: {self.results.get('target')}")
+        print(f"Status: {self.results.get('status')}")
+        print(f"Findings: {len(self.results.get('findings', []))}")
+        print("="*50 + "\n")
+
+def main():
+    """Main entry point"""
+    parser = argparse.ArgumentParser(
+        description="Project Architect"
+    )
+    parser.add_argument(
+        'target',
+        help='Target path to analyze or process'
+    )
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose output'
+    )
+    parser.add_argument(
+        '--json',
+        action='store_true',
+        help='Output results as JSON'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        help='Output file path'
+    )
+    
+    args = parser.parse_args()
+    
+    tool = ProjectArchitect(
+        args.target,
+        verbose=args.verbose
+    )
+    
+    results = tool.run()
+    
+    if args.json:
+        output = json.dumps(results, indent=2)
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(output)
+            print(f"Results written to {args.output}")
+        else:
+            print(output)
+
+if __name__ == '__main__':
+    main()

package/templates/vault/shopify-development/scripts/requirements.txt

@@ -0,0 +1,19 @@
+# Shopify Skill Dependencies
+# Python 3.10+ required
+
+# No Python package dependencies - uses only standard library
+
+# Testing dependencies (dev)
+pytest>=8.0.0
+pytest-cov>=4.1.0
+pytest-mock>=3.12.0
+
+# Note: This script requires the Shopify CLI tool
+# Install Shopify CLI:
+#   npm install -g @shopify/cli @shopify/theme
+#   or via Homebrew (macOS):
+#   brew tap shopify/shopify
+#   brew install shopify-cli
+#
+# Authenticate with:
+#   shopify auth login