@codihaus/claude-skills 1.0.0

package/skills/utils/gemini/scripts/gemini-scan.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+Gemini Codebase Scanner
+
+Scans a codebase using Gemini Flash's large context window
+and produces a structured summary for Claude Code to use.
+
+Usage:
+    python gemini-scan.py --path /path/to/project --output summary.md
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Set
+
+# Check for google-generativeai
+try:
+    import google.generativeai as genai
+except ImportError:
+    print("Error: google-generativeai not installed")
+    print("Run: pip install google-generativeai")
+    sys.exit(1)
+
+
+# Default file extensions to include
+DEFAULT_EXTENSIONS = {
+    # JavaScript/TypeScript
+    '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+    # Python
+    '.py',
+    # Web
+    '.html', '.css', '.scss', '.sass', '.less',
+    # Config
+    '.json', '.yaml', '.yml', '.toml', '.env.example',
+    # Docs
+    '.md', '.mdx',
+    # Other
+    '.sql', '.graphql', '.prisma',
+    # Config files (no extension)
+}
+
+# Files to always include (by name)
+INCLUDE_FILES = {
+    'package.json', 'tsconfig.json', 'next.config.js', 'next.config.mjs',
+    'vite.config.ts', 'vite.config.js', 'tailwind.config.js', 'tailwind.config.ts',
+    'prisma/schema.prisma', '.env.example', 'docker-compose.yml', 'Dockerfile',
+    'requirements.txt', 'pyproject.toml', 'Cargo.toml', 'go.mod',
+    'README.md', 'CLAUDE.md',
+}
+
+# Default ignore patterns
+DEFAULT_IGNORE = {
+    'node_modules', '.git', '.next', '.nuxt', 'dist', 'build', 'out',
+    '__pycache__', '.pytest_cache', '.mypy_cache', 'venv', '.venv',
+    'coverage', '.coverage', 'htmlcov', '.nyc_output',
+    '.idea', '.vscode', '*.log', '*.lock',
+    'vendor', 'target', 'bin', 'obj',
+}
+
+DEFAULT_PROMPT = """Analyze this codebase and provide a structured summary:
+
+1. **Project Overview**
+   - What does this project do? (1-2 sentences)
+   - Main technologies/frameworks used
+
+2. **File Organization**
+   - Key directories and their purposes
+   - Entry points (main files)
+   - Configuration files
+
+3. **Architecture Patterns**
+   - Overall architecture (MVC, component-based, microservices, etc.)
+   - Coding conventions observed
+   - State management approach (if frontend)
+
+4. **Key Files** (most important files to understand the project)
+   - Entry points
+   - Core business logic
+   - API/route definitions
+   - Database models/schema
+
+5. **Dependencies**
+   - Key external packages and their purpose
+   - Internal module structure
+
+6. **For Scout** (recommendations for deeper analysis)
+   - Which files/folders need closer inspection
+   - Potential complexity areas
+   - Suggested focus areas
+
+Be concise but comprehensive. Use markdown formatting with headers and tables where appropriate.
+"""
+
+
+def load_gitignore(path: Path) -> Set[str]:
+    """Load patterns from .gitignore file."""
+    gitignore_path = path / '.gitignore'
+    patterns = set()
+
+    if gitignore_path.exists():
+        with open(gitignore_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    # Simple pattern handling
+                    patterns.add(line.rstrip('/'))
+
+    return patterns
+
+
+def should_ignore(path: Path, ignore_patterns: Set[str]) -> bool:
+    """Check if path should be ignored."""
+    name = path.name
+
+    # Check against ignore patterns
+    for pattern in ignore_patterns:
+        if pattern.startswith('*'):
+            if name.endswith(pattern[1:]):
+                return True
+        elif name == pattern or pattern in str(path):
+            return True
+
+    return False
+
+
+def collect_files(
+    root_path: Path,
+    extensions: Set[str],
+    ignore_patterns: Set[str],
+    max_files: int
+) -> List[Path]:
+    """Collect files from the directory."""
+    files = []
+
+    for path in root_path.rglob('*'):
+        if len(files) >= max_files:
+            break
+
+        if not path.is_file():
+            continue
+
+        if should_ignore(path, ignore_patterns):
+            continue
+
+        # Check if it's in INCLUDE_FILES or has valid extension
+        rel_path = str(path.relative_to(root_path))
+        if rel_path in INCLUDE_FILES or path.name in INCLUDE_FILES:
+            files.append(path)
+        elif path.suffix.lower() in extensions:
+            files.append(path)
+
+    return sorted(files)
+
+
+def read_file_content(path: Path, max_lines: int = 500) -> str:
+    """Read file content with line limit."""
+    try:
+        with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+            lines = f.readlines()
+
+        if len(lines) > max_lines:
+            content = ''.join(lines[:max_lines])
+            content += f"\n... (truncated, {len(lines) - max_lines} more lines)"
+        else:
+            content = ''.join(lines)
+
+        return content
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+
+def build_codebase_content(root_path: Path, files: List[Path]) -> str:
+    """Build the codebase content string."""
+    parts = []
+
+    # Add file tree first
+    parts.append("# File Structure\n")
+    parts.append("```")
+
+    # Build simple tree
+    for f in files[:100]:  # Limit tree display
+        rel_path = f.relative_to(root_path)
+        parts.append(str(rel_path))
+
+    if len(files) > 100:
+        parts.append(f"... and {len(files) - 100} more files")
+
+    parts.append("```\n")
+
+    # Add file contents
+    parts.append("# File Contents\n")
+
+    for f in files:
+        rel_path = f.relative_to(root_path)
+        content = read_file_content(f)
+
+        parts.append(f"\n## {rel_path}\n")
+        parts.append(f"```{f.suffix[1:] if f.suffix else ''}")
+        parts.append(content)
+        parts.append("```\n")
+
+    return '\n'.join(parts)
+
+
+def scan_with_gemini(content: str, prompt: str, api_key: str) -> str:
+    """Send content to Gemini and get summary."""
+    genai.configure(api_key=api_key)
+
+    model = genai.GenerativeModel(
+        model_name="gemini-1.5-flash",
+        generation_config={
+            "temperature": 0.3,
+            "max_output_tokens": 8192,
+        }
+    )
+
+    full_prompt = f"{prompt}\n\n---\n\n{content}"
+
+    print(f"Sending to Gemini ({len(full_prompt):,} characters)...")
+
+    response = model.generate_content(full_prompt)
+
+    return response.text
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Scan codebase with Gemini Flash'
+    )
+    parser.add_argument(
+        '--path', '-p',
+        type=str,
+        default='.',
+        help='Path to scan (default: current directory)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        help='Output file path (default: stdout)'
+    )
+    parser.add_argument(
+        '--prompt',
+        type=str,
+        default=DEFAULT_PROMPT,
+        help='Custom prompt for Gemini'
+    )
+    parser.add_argument(
+        '--extensions', '-e',
+        type=str,
+        nargs='+',
+        help='File extensions to include (e.g., .py .js)'
+    )
+    parser.add_argument(
+        '--max-files', '-m',
+        type=int,
+        default=500,
+        help='Maximum files to process (default: 500)'
+    )
+    parser.add_argument(
+        '--ignore', '-i',
+        type=str,
+        nargs='+',
+        help='Additional patterns to ignore'
+    )
+
+    args = parser.parse_args()
+
+    # Check API key
+    api_key = os.environ.get('GEMINI_API_KEY')
+    if not api_key:
+        print("Error: GEMINI_API_KEY environment variable not set")
+        print("Run the setup script: ./scripts/setup.sh")
+        sys.exit(1)
+
+    # Setup paths
+    root_path = Path(args.path).resolve()
+    if not root_path.exists():
+        print(f"Error: Path does not exist: {root_path}")
+        sys.exit(1)
+
+    print(f"Scanning: {root_path}")
+
+    # Setup extensions
+    extensions = set(args.extensions) if args.extensions else DEFAULT_EXTENSIONS
+
+    # Setup ignore patterns
+    ignore_patterns = DEFAULT_IGNORE.copy()
+    ignore_patterns.update(load_gitignore(root_path))
+    if args.ignore:
+        ignore_patterns.update(args.ignore)
+
+    # Collect files
+    print("Collecting files...")
+    files = collect_files(root_path, extensions, ignore_patterns, args.max_files)
+    print(f"Found {len(files)} files")
+
+    if not files:
+        print("No files found to scan")
+        sys.exit(1)
+
+    # Build content
+    print("Building content...")
+    content = build_codebase_content(root_path, files)
+
+    # Scan with Gemini
+    try:
+        result = scan_with_gemini(content, args.prompt, api_key)
+    except Exception as e:
+        print(f"Error calling Gemini API: {e}")
+        sys.exit(1)
+
+    # Add metadata header
+    output = f"""# Gemini Codebase Summary
+
+> Generated by: gemini-scan.py
+> Path: {root_path}
+> Files scanned: {len(files)}
+> Model: gemini-1.5-flash
+
+---
+
+{result}
+"""
+
+    # Output
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, 'w') as f:
+            f.write(output)
+        print(f"Output written to: {output_path}")
+    else:
+        print("\n" + "="*60 + "\n")
+        print(output)
+
+
+if __name__ == '__main__':
+    main()

package/skills/utils/gemini/scripts/setup.sh

@@ -0,0 +1,169 @@
+#!/bin/bash
+
+# Gemini Setup Script
+# Sets up API key and verifies connection
+
+echo "========================================"
+echo "  Gemini Flash Setup for Claude Code"
+echo "========================================"
+echo ""
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Check if API key already exists
+if [ -n "$GEMINI_API_KEY" ]; then
+    echo -e "${GREEN}[OK]${NC} GEMINI_API_KEY found in environment"
+    EXISTING_KEY=true
+else
+    echo -e "${YELLOW}[!]${NC} GEMINI_API_KEY not found"
+    EXISTING_KEY=false
+fi
+
+# Check .env file
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+ENV_FILE="$PROJECT_ROOT/.env"
+
+if [ -f "$ENV_FILE" ]; then
+    if grep -q "GEMINI_API_KEY" "$ENV_FILE"; then
+        echo -e "${GREEN}[OK]${NC} GEMINI_API_KEY found in .env file"
+        # Source it
+        export $(grep "GEMINI_API_KEY" "$ENV_FILE" | xargs)
+        EXISTING_KEY=true
+    fi
+fi
+
+echo ""
+
+if [ "$EXISTING_KEY" = false ]; then
+    echo "To get a Gemini API key:"
+    echo ""
+    echo "1. Go to: https://aistudio.google.com/app/apikey"
+    echo "2. Click 'Create API key'"
+    echo "3. Copy the key"
+    echo ""
+    read -p "Enter your Gemini API key: " API_KEY
+
+    if [ -z "$API_KEY" ]; then
+        echo -e "${RED}[ERROR]${NC} No API key provided"
+        exit 1
+    fi
+
+    # Save to .env file
+    echo ""
+    echo "Where to save the API key?"
+    echo "1. Project .env file (recommended)"
+    echo "2. Shell profile (~/.bashrc or ~/.zshrc)"
+    echo "3. Both"
+    read -p "Choice [1]: " SAVE_CHOICE
+    SAVE_CHOICE=${SAVE_CHOICE:-1}
+
+    case $SAVE_CHOICE in
+        1)
+            echo "GEMINI_API_KEY=$API_KEY" >> "$ENV_FILE"
+            echo -e "${GREEN}[OK]${NC} Saved to $ENV_FILE"
+            ;;
+        2)
+            SHELL_PROFILE="$HOME/.bashrc"
+            if [ -f "$HOME/.zshrc" ]; then
+                SHELL_PROFILE="$HOME/.zshrc"
+            fi
+            echo "export GEMINI_API_KEY=$API_KEY" >> "$SHELL_PROFILE"
+            echo -e "${GREEN}[OK]${NC} Saved to $SHELL_PROFILE"
+            echo -e "${YELLOW}[!]${NC} Run: source $SHELL_PROFILE"
+            ;;
+        3)
+            echo "GEMINI_API_KEY=$API_KEY" >> "$ENV_FILE"
+            SHELL_PROFILE="$HOME/.bashrc"
+            if [ -f "$HOME/.zshrc" ]; then
+                SHELL_PROFILE="$HOME/.zshrc"
+            fi
+            echo "export GEMINI_API_KEY=$API_KEY" >> "$SHELL_PROFILE"
+            echo -e "${GREEN}[OK]${NC} Saved to both"
+            ;;
+    esac
+
+    export GEMINI_API_KEY="$API_KEY"
+fi
+
+echo ""
+echo "Checking Python dependencies..."
+
+# Check Python
+if ! command -v python3 &> /dev/null; then
+    echo -e "${RED}[ERROR]${NC} Python 3 not found"
+    echo "Install Python 3 first: https://www.python.org/downloads/"
+    exit 1
+fi
+echo -e "${GREEN}[OK]${NC} Python 3 found"
+
+# Check google-generativeai
+if python3 -c "import google.generativeai" 2>/dev/null; then
+    echo -e "${GREEN}[OK]${NC} google-generativeai installed"
+else
+    echo -e "${YELLOW}[!]${NC} google-generativeai not installed"
+    read -p "Install now? [Y/n]: " INSTALL
+    INSTALL=${INSTALL:-Y}
+    if [[ $INSTALL =~ ^[Yy]$ ]]; then
+        pip install google-generativeai
+        if [ $? -eq 0 ]; then
+            echo -e "${GREEN}[OK]${NC} Installed successfully"
+        else
+            echo -e "${RED}[ERROR]${NC} Installation failed"
+            exit 1
+        fi
+    else
+        echo "Please run: pip install google-generativeai"
+        exit 1
+    fi
+fi
+
+echo ""
+echo "Testing connection..."
+
+# Test API
+python3 << 'EOF'
+import os
+import sys
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    print("ERROR: google-generativeai not installed")
+    sys.exit(1)
+
+api_key = os.environ.get("GEMINI_API_KEY")
+if not api_key:
+    print("ERROR: GEMINI_API_KEY not set")
+    sys.exit(1)
+
+try:
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-1.5-flash")
+    response = model.generate_content("Say 'Hello from Gemini!' in exactly those words.")
+    print(f"Response: {response.text.strip()}")
+    print("SUCCESS: Gemini API working!")
+except Exception as e:
+    print(f"ERROR: {e}")
+    sys.exit(1)
+EOF
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo -e "${GREEN}========================================"
+    echo "  Setup Complete!"
+    echo "========================================${NC}"
+    echo ""
+    echo "You can now use Gemini for codebase scanning:"
+    echo ""
+    echo "  python scripts/gemini-scan.py --path /your/project"
+    echo ""
+else
+    echo ""
+    echo -e "${RED}Setup failed. Check errors above.${NC}"
+    exit 1
+fi

package/src/commands/add.js

@@ -0,0 +1,64 @@
+/**
+ * add command
+ *
+ * Add a specific skill to the project.
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getAvailableSkills, getInstalledSkills, copySkillsToProject } from '../utils/skills.js';
+
+export async function add(skillName) {
+  const projectPath = process.cwd();
+
+  console.log(chalk.bold(`\n➕ Adding skill: ${skillName}\n`));
+
+  // Check if skill exists
+  const available = await getAvailableSkills();
+  const skill = available.find(s => s.name === skillName);
+
+  if (!skill) {
+    console.log(chalk.red(`❌ Skill not found: ${skillName}\n`));
+    console.log('Available skills:');
+
+    for (const s of available.filter(s => s.type !== 'config')) {
+      console.log(`  - ${s.name}`);
+    }
+
+    console.log('');
+    process.exit(1);
+  }
+
+  // Check if already installed
+  const installed = await getInstalledSkills(projectPath);
+  const alreadyInstalled = installed.find(s => s.name === skillName);
+
+  if (alreadyInstalled) {
+    console.log(chalk.yellow(`⚠️  Skill already installed: ${skillName}\n`));
+    console.log(chalk.gray('Use `claude-skills update` to update to latest version.\n'));
+    process.exit(0);
+  }
+
+  // Install the skill
+  const spinner = ora(`Installing ${skillName}...`).start();
+
+  try {
+    const { copied, errors } = await copySkillsToProject(projectPath, [skillName]);
+
+    if (errors.length > 0) {
+      spinner.fail(`Failed to install ${skillName}`);
+      console.log(chalk.red(errors[0].error));
+      process.exit(1);
+    }
+
+    spinner.succeed(`Installed ${skillName}`);
+  } catch (e) {
+    spinner.fail('Installation failed');
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`\n✅ ${skillName} added successfully!\n`));
+  console.log(`Try it: ${chalk.cyan(`/${skillName}`)}\n`);
+}