enhance_swarm 1.0.0

data/lib/enhance_swarm/web_ui.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'json'
+require 'erb'
+require_relative 'logger'
+require_relative 'orchestrator'
+require_relative 'process_monitor'
+
+module EnhanceSwarm
+  class WebUI
+    attr_reader :server, :port
+
+    def initialize(port: 4567, host: 'localhost')
+      @port = port
+      @host = host
+      @orchestrator = Orchestrator.new
+      @process_monitor = ProcessMonitor.new
+      setup_server
+    end
+
+    def start
+      Logger.info("Starting EnhanceSwarm Web UI on http://#{@host}:#{@port}")
+      puts "🌐 EnhanceSwarm Web UI starting on http://#{@host}:#{@port}".colorize(:blue)
+      puts "   📋 Features: Task Management, Kanban Board, Agent Monitoring"
+      puts "   🚀 Open your browser to access the interface"
+      puts "   ⏹️  Press Ctrl+C to stop the server"
+      
+      trap 'INT' do
+        puts "\n👋 Shutting down EnhanceSwarm Web UI..."
+        @server.shutdown
+      end
+
+      @server.start
+    end
+
+    def stop
+      @server&.shutdown
+    end
+
+    private
+
+    def setup_server
+      @server = WEBrick::HTTPServer.new(
+        Port: @port,
+        Host: @host,
+        Logger: WEBrick::Log.new('/dev/null'),
+        AccessLog: []
+      )
+
+      # Static assets
+      @server.mount('/assets', WEBrick::HTTPServlet::FileHandler, assets_dir)
+      
+      # API endpoints
+      setup_api_routes
+      
+      # Main UI routes
+      setup_ui_routes
+    end
+
+    def setup_api_routes
+      # Status API
+      @server.mount_proc('/api/status') do |req, res|
+        res['Content-Type'] = 'application/json'
+        status_data = @process_monitor.status
+        res.body = JSON.pretty_generate(status_data)
+      end
+
+      # Task management API
+      @server.mount_proc('/api/tasks') do |req, res|
+        res['Content-Type'] = 'application/json'
+        task_data = @orchestrator.get_task_management_data
+        res.body = JSON.pretty_generate(task_data)
+      end
+
+      # Agent spawn API
+      @server.mount_proc('/api/agents/spawn') do |req, res|
+        res['Content-Type'] = 'application/json'
+        
+        if req.request_method == 'POST'
+          begin
+            body = JSON.parse(req.body)
+            role = body['role'] || 'general'
+            task = body['task'] || 'General task'
+            worktree = body['worktree'] || true
+            
+            result = @orchestrator.spawn_single(task: task, role: role, worktree: worktree)
+            
+            if result
+              res.body = JSON.generate({ success: true, pid: result, message: "#{role.capitalize} agent spawned successfully" })
+            else
+              res.status = 400
+              res.body = JSON.generate({ success: false, message: "Failed to spawn #{role} agent" })
+            end
+          rescue JSON::ParserError
+            res.status = 400
+            res.body = JSON.generate({ success: false, message: 'Invalid JSON in request body' })
+          rescue StandardError => e
+            res.status = 500
+            res.body = JSON.generate({ success: false, message: e.message })
+          end
+        else
+          res.status = 405
+          res.body = JSON.generate({ success: false, message: 'Method not allowed' })
+        end
+      end
+
+      # Configuration API
+      @server.mount_proc('/api/config') do |req, res|
+        res['Content-Type'] = 'application/json'
+        config_data = EnhanceSwarm.configuration.to_h
+        res.body = JSON.pretty_generate(config_data)
+      end
+
+      # Project analysis API
+      @server.mount_proc('/api/project/analyze') do |req, res|
+        res['Content-Type'] = 'application/json'
+        
+        begin
+          analyzer = ProjectAnalyzer.new
+          analysis = analyzer.analyze
+          smart_defaults = analyzer.generate_smart_defaults
+          
+          res.body = JSON.pretty_generate({
+            analysis: analysis,
+            smart_defaults: smart_defaults
+          })
+        rescue StandardError => e
+          res.status = 500
+          res.body = JSON.generate({ error: e.message })
+        end
+      end
+    end
+
+    def setup_ui_routes
+      # Main dashboard
+      @server.mount_proc('/') do |req, res|
+        res['Content-Type'] = 'text/html'
+        res.body = render_template('dashboard')
+      end
+
+      # Kanban board
+      @server.mount_proc('/kanban') do |req, res|
+        res['Content-Type'] = 'text/html'
+        res.body = render_template('kanban')
+      end
+
+      # Agent monitoring
+      @server.mount_proc('/agents') do |req, res|
+        res['Content-Type'] = 'text/html'
+        res.body = render_template('agents')
+      end
+
+      # Project overview
+      @server.mount_proc('/project') do |req, res|
+        res['Content-Type'] = 'text/html'
+        res.body = render_template('project')
+      end
+
+      # Configuration
+      @server.mount_proc('/config') do |req, res|
+        res['Content-Type'] = 'text/html'
+        res.body = render_template('config')
+      end
+    end
+
+    def render_template(template_name)
+      template_path = File.join(templates_dir, "#{template_name}.html.erb")
+      
+      unless File.exist?(template_path)
+        return error_template("Template not found: #{template_name}")
+      end
+
+      begin
+        template = ERB.new(File.read(template_path))
+        template.result(binding)
+      rescue StandardError => e
+        Logger.error("Template rendering error: #{e.message}")
+        error_template("Template error: #{e.message}")
+      end
+    end
+
+    def error_template(message)
+      <<~HTML
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>EnhanceSwarm - Error</title>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body style="font-family: -apple-system, sans-serif; padding: 2rem; background: #f5f5f5;">
+          <div style="max-width: 600px; margin: 0 auto; background: white; padding: 2rem; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
+            <h1 style="color: #e74c3c; margin-top: 0;">⚠️ EnhanceSwarm Error</h1>
+            <p style="color: #666; font-size: 1.1rem;">#{message}</p>
+            <a href="/" style="display: inline-block; margin-top: 1rem; padding: 0.5rem 1rem; background: #3498db; color: white; text-decoration: none; border-radius: 4px;">← Back to Dashboard</a>
+          </div>
+        </body>
+        </html>
+      HTML
+    end
+
+    def templates_dir
+      File.join(File.dirname(__FILE__), '..', '..', 'web', 'templates')
+    end
+
+    def assets_dir
+      File.join(File.dirname(__FILE__), '..', '..', 'web', 'assets')
+    end
+  end
+end

data/lib/enhance_swarm.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'enhance_swarm/version'
+require_relative 'enhance_swarm/configuration'
+require_relative 'enhance_swarm/command_executor'
+require_relative 'enhance_swarm/retry_handler'
+require_relative 'enhance_swarm/logger'
+require_relative 'enhance_swarm/dependency_validator'
+require_relative 'enhance_swarm/cleanup_manager'
+require_relative 'enhance_swarm/signal_handler'
+require_relative 'enhance_swarm/agent_reviewer'
+require_relative 'enhance_swarm/progress_tracker'
+require_relative 'enhance_swarm/output_streamer'
+require_relative 'enhance_swarm/control_agent'
+require_relative 'enhance_swarm/notification_manager'
+require_relative 'enhance_swarm/interrupt_handler'
+require_relative 'enhance_swarm/agent_communicator'
+require_relative 'enhance_swarm/visual_dashboard'
+require_relative 'enhance_swarm/smart_defaults'
+require_relative 'enhance_swarm/error_recovery'
+require_relative 'enhance_swarm/cli'
+require_relative 'enhance_swarm/orchestrator'
+require_relative 'enhance_swarm/monitor'
+require_relative 'enhance_swarm/task_manager'
+require_relative 'enhance_swarm/generator'
+require_relative 'enhance_swarm/mcp_integration'
+
+module EnhanceSwarm
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class CommandError < Error; end
+
+  class << self
+    def configure
+      yield(configuration)
+    rescue StandardError => e
+      raise ConfigurationError, "Configuration failed: #{e.message}"
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    rescue StandardError => e
+      raise ConfigurationError, "Failed to initialize configuration: #{e.message}"
+    end
+
+    def root
+      @root ||= find_project_root
+    rescue StandardError => e
+      puts "Warning: Could not determine project root: #{e.message}"
+      Dir.pwd
+    end
+
+    def enhance!
+      Orchestrator.new.enhance
+    rescue StandardError => e
+      puts "Enhancement failed: #{e.message}".colorize(:red)
+      false
+    end
+
+    private
+
+    def find_project_root
+      current = Dir.pwd
+      current = File.dirname(current) while current != '/' && !File.exist?(File.join(current, '.enhance_swarm.yml'))
+
+      File.exist?(File.join(current, '.enhance_swarm.yml')) ? current : Dir.pwd
+    end
+  end
+end

data/setup.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+set -e
+
+# EnhanceSwarm Auto-Setup Script
+# This script can be run directly from GitHub to set up EnhanceSwarm in any project
+
+echo "🚀 EnhanceSwarm Auto-Setup"
+echo "========================="
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Check dependencies
+echo -e "\n${YELLOW}Checking dependencies...${NC}"
+
+check_dependency() {
+    if command -v $1 &> /dev/null; then
+        echo -e "  ✅ $1 found"
+        return 0
+    else
+        echo -e "  ❌ $1 not found"
+        return 1
+    fi
+}
+
+MISSING_DEPS=0
+check_dependency "ruby" || MISSING_DEPS=1
+check_dependency "git" || MISSING_DEPS=1
+check_dependency "bundle" || MISSING_DEPS=1
+
+if [ $MISSING_DEPS -eq 1 ]; then
+    echo -e "\n${RED}Missing required dependencies. Please install them first.${NC}"
+    exit 1
+fi
+
+# Clone or update enhance_swarm
+ENHANCE_DIR="$HOME/.enhance_swarm"
+
+if [ -d "$ENHANCE_DIR" ]; then
+    echo -e "\n${YELLOW}Updating EnhanceSwarm...${NC}"
+    cd "$ENHANCE_DIR"
+    git pull origin main
+else
+    echo -e "\n${YELLOW}Installing EnhanceSwarm...${NC}"
+    git clone https://github.com/todddickerson/enhance_swarm.git "$ENHANCE_DIR"
+    cd "$ENHANCE_DIR"
+fi
+
+# Install gem dependencies
+echo -e "\n${YELLOW}Installing dependencies...${NC}"
+bundle install
+
+# Build and install the gem
+echo -e "\n${YELLOW}Building and installing gem...${NC}"
+rake build
+gem install pkg/enhance_swarm-*.gem
+
+# Check optional dependencies
+echo -e "\n${YELLOW}Checking optional dependencies...${NC}"
+check_dependency "claude" || echo "  ⚠️  Install Claude CLI for enhanced agent spawning"
+check_dependency "gemini" || echo "  ⚠️  Install Gemini CLI for large context analysis"
+
+# Initialize in current project if we're in a project directory
+if [ -f "Gemfile" ] || [ -f "package.json" ] || [ -f ".git/config" ]; then
+    echo -e "\n${YELLOW}Detected project directory. Initialize EnhanceSwarm here?${NC}"
+    read -p "Initialize EnhanceSwarm in current directory? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        enhance-swarm init
+    fi
+else
+    echo -e "\n${GREEN}✅ EnhanceSwarm installed successfully!${NC}"
+    echo -e "\nTo initialize in a project, run:"
+    echo -e "  ${YELLOW}cd your-project${NC}"
+    echo -e "  ${YELLOW}enhance-swarm init${NC}"
+fi
+
+echo -e "\n${GREEN}🎉 Setup complete!${NC}"
+echo -e "\nAvailable commands:"
+echo "  enhance-swarm init      - Initialize in a project"
+echo "  enhance-swarm enhance   - Run ENHANCE protocol"
+echo "  enhance-swarm doctor    - Check system setup"
+echo "  enhance-swarm --help    - See all commands"

data/sig/enhance_swarm.rbs

@@ -0,0 +1,4 @@
+module EnhanceSwarm
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/templates/claude/CLAUDE.md

@@ -0,0 +1,160 @@
+# CLAUDE.md - <%= project_name %> Project Instructions
+
+## Project Overview
+<%= project_description %>
+
+## Key Technologies
+<%= technology_stack %>
+
+## Development Guidelines
+
+### For Swarm Agents
+When working on tasks:
+1. **You have FULL AUTONOMY** - Do not wait for permission to make changes
+2. **Always run tests** - Use `<%= test_command %>` to verify your work
+3. **Commit and push** - Always commit your changes and push to a feature branch
+4. **Fix issues completely** - Don't leave work half-done
+
+### CRITICAL: Multi-Agent Orchestration for Complex Tasks
+
+**"ENHANCE" KEYWORD = FULL ORCHESTRATION PROTOCOL**
+
+When user says "enhance", ALWAYS:
+1. Identify next priority task(s) from backlog
+2. Orchestrate multi-agent parallel implementation
+3. Monitor all work to completion
+4. Review, merge, and integrate
+5. Clean up all worktrees and branches
+6. Commit and push everything
+7. Update task statuses
+8. Provide completion summary
+
+**ALWAYS use Claude Swarm orchestration for features requiring multiple components** (e.g., models + UI + tests):
+
+1. **Break down the task** into parallel work for specialists:
+   - UX Designer: UI/email templates
+   - Backend Developer: Models, services, APIs
+   - Frontend Developer: Controllers, views, JavaScript
+   - QA Lead: Comprehensive test coverage
+
+2. **Spawn parallel agents** (DO NOT implement directly):
+   ```bash
+   # First move task to active
+   <%= task_move_command %> <task-id> active
+   
+   # Then spawn specialists in parallel
+   claude-swarm start -p "UX_TASK: [specific design work from task]" --worktree &
+   claude-swarm start -p "BACKEND_TASK: [specific backend work from task]" --worktree &
+   claude-swarm start -p "FRONTEND_TASK: [specific frontend work from task]" --worktree &
+   claude-swarm start -p "QA_TASK: [specific testing work from task]" --worktree &
+   
+   sleep 5  # Wait for initialization
+   ```
+
+3. **Monitor progress** every 30 seconds:
+   ```bash
+   while claude-swarm ps | grep -q "running"; do
+     echo "Checking status..."
+     claude-swarm ps
+     sleep 30
+   done
+   ```
+
+4. **Review and iterate** on completed work
+5. **Only mark task complete** after all agents finish and work is merged
+
+**Single-agent tasks** (simple fixes, documentation, configuration):
+- Implement directly without orchestration
+- Examples: Fix typo, update config, add single method
+
+### Code Standards
+<%= code_standards %>
+
+### Git Workflow
+```bash
+# Stage all changes
+git add -A
+
+# Commit with descriptive message
+git commit -m "Add feature: description
+
+- Detail 1
+- Detail 2"
+
+# Push to feature branch
+git checkout -b feature/description
+git push origin HEAD
+```
+
+### Common Tasks
+
+#### Fix Failing Tests
+1. Run tests to see failures: `<%= test_command %>`
+2. Read error messages carefully
+3. Check for missing database columns
+4. Ensure test data is valid
+5. Mock external services properly
+6. Run tests again to verify
+
+#### Add New Feature
+1. Create necessary models/migrations
+2. Add services for business logic
+3. Create controllers and routes
+4. Build UI components
+5. Write comprehensive tests
+6. Document in commit message
+
+## Task Management Process
+
+### Working with Tasks - Use the `<%= task_command %>` Command
+```bash
+# List tasks
+<%= task_command %> list          # Show all tasks
+<%= task_command %> list active   # Show active tasks
+<%= task_command %> list backlog  # Show backlog
+
+# Move tasks between states
+<%= task_command %> move <task-id> active     # Start working on a task
+<%= task_command %> move <task-id> completed  # Mark task as done
+
+# View task details
+<%= task_command %> show <task-id>
+
+# Get statistics
+<%= task_command %> stats
+
+# Create new tasks
+<%= task_command %> create "Task Title" --effort 4 --tags backend,api
+
+# For AI agents - use JSON output
+<%= task_command %> list active --json
+```
+
+### For Swarm Agents
+1. **Check for tasks**: `<%= task_command %> list active --json`
+2. **Start a task**: `<%= task_command %> move <task-id> active`
+3. **Complete a task**: `<%= task_command %> move <task-id> completed`
+4. **Commit and push changes**: 
+   ```bash
+   git add -A
+   git commit -m "Complete task: <task-id> - <description>"
+   git push origin main  # or feature branch
+   ```
+5. **Never use manual mv commands** - always use the <%= task_command %> gem
+
+### Task File Format
+Each task file should contain:
+- **Status**: (implicit by directory location)
+- **Description**: What needs to be done
+- **Acceptance Criteria**: How we know it's complete
+- **Time Estimate**: Hours expected
+- **Actual Time**: Hours spent (update when complete)
+
+## Important Notes
+<%= important_notes %>
+
+# important-instruction-reminders
+Do what has been asked; nothing more, nothing less.
+NEVER create files unless they're absolutely necessary for achieving your goal.
+ALWAYS prefer editing an existing file to creating a new one.
+NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.

data/templates/claude/MCP.md

@@ -0,0 +1,117 @@
+# MCP.md - Model Context Protocol Ops
+
+## Legend
+| Symbol | Meaning | | Abbrev | Meaning |
+|--------|---------|---|--------|---------|
+| → | leads to | | ops | operations |
+| & | and/with | | UI | user interface |
+| w/ | with | | impl | implementation |
+
+## Decision Matrix
+
+```yaml
+Flag Control:
+  --c7: Force Context7→docs | --seq: Force Sequential→analysis | --magic: Force Magic→UI
+  --pup: Force Puppeteer→browser | --all-mcp: Enable all | --no-mcp: Disable all
+
+User Triggers (no flags):
+  "docs for X" → C7(resolve-library-id: X) → get-docs
+  "how to use Y in Z" → C7(resolve-library-id: Z) → get-docs(topic: Y)
+  "need button/form/component" → Magic(builder) → integrate
+  "why slow/broken" → Sequential(analysis) → impl fix
+  "design architecture" → Sequential(system design) → C7(patterns)
+
+Context Triggers (flags override):
+  Import errors → C7(resolve-library-id) → verify docs
+  Complex debugging → Sequential(root cause) → native impl
+  UI requests → Magic(builder/refiner) → Puppeteer(test)
+  Perf issues → Sequential(analysis) → optimize impl
+
+Research-First (shared/research-first.yml):
+  External lib detected → C7 lookup REQUIRED (blocks w/o docs)
+  New component → Magic search REQUIRED or existing pattern
+  API integration → WebSearch REQUIRED for official docs
+  Unknown pattern → Sequential thinking + research REQUIRED
+  Confidence < 90% → Impl BLOCKED until research complete
+
+Task Complexity:
+  Simple queries → Native tools only (unless flagged)
+  Lib questions → C7 progressive loading (or --c7)
+  Multi-step problems → Sequential adaptive thinking (or --seq)
+  UI generation → Magic + integration (or --magic)
+  Full workflows → Multi-MCP orchestration (or --all-mcp)
+```
+
+## Execution Playbooks
+
+```yaml
+Lib Research: C7 resolve-library-id w/ user term → options if multiple → C7 get-docs w/ topic → Sequential if insufficient → impl
+Ex: "React forms?" → C7 resolve("react") → C7 get-docs(topic:"forms") → impl form code
+
+Complex Analysis: Sequential problem decomposition → guide C7 docs lookup → combine analysis+docs→impl plan → execute w/ native
+Ex: "App slow debug" → Sequential(analyze perf bottlenecks) → C7 get-docs optimization patterns → impl fixes
+
+UI Generation: Magic builder w/ user requirements+project context → Magic refiner if needed → integrate component → Puppeteer validation
+Ex: "Dashboard w/ charts" → Magic builder("dashboard","charts") → edit files integrate → Puppeteer screenshot
+```
+
+## Token Economics
+
+```yaml
+Budget: Native:0 | Light MCP:100-500 | Medium MCP:500-2K | Heavy MCP:2K-10K
+Escalation: 1.Native first simple tasks 2.C7 lib questions 3.Sequential complex analysis 4.Combine MCPs synergy
+Abort: >50% context→native | MCP timeout/error→fallback | Diminishing returns→stop MCP
+Cost: Quick→C7 only | Architecture→Sequential | UI→Magic | Else→Native
+UltraCompressed: --uc flag|High context|Token budget | ~70% reduction | Clarity→conciseness | Legend auto-gen
+```
+
+## Quality Control
+
+```yaml
+C7: ✓Relevant docs→Proceed | ⚠Partial→Try different terms | ✗No match→Sequential alternatives
+Sequential: ✓Clear analysis+steps→Impl | ⚠Partial→Continue thoughts | ✗Unclear/timeout→Native+user questions
+Magic: ✓Component matches→Integrate | ⚠Close needs changes→Refiner | ✗Poor→Try different terms
+Multi-MCP: Results enhance each other | Conflict→Most authoritative | Redundant→Stop calls
+```
+
+## Persona Integration
+
+```yaml
+Persona Preferences:
+  architect: Sequential(design)+C7(patterns)+avoid Magic | frontend: Magic(UI)+Puppeteer(test)+C7(React/Vue docs)
+  backend: C7(API docs)+Sequential(scale analysis)+avoid Magic | analyzer: Sequential(root cause) primary+C7(solutions) secondary
+  security: Sequential(threats)+C7(security patterns)+Puppeteer(test) | mentor: C7(learning)+Sequential(explanations)+avoid Magic
+  refactorer: Sequential(analysis)+C7(patterns)+avoid Magic/Puppeteer | perf: Sequential(bottlenecks)+Puppeteer(metrics)+C7(optimization)
+  qa: Puppeteer(testing)+Sequential(edge cases)+C7(testing frameworks)
+
+Behaviors: architect→Long Sequential system design | frontend→Quick Magic components | analyzer→Deep Sequential before solutions
+```
+
+## Command Integration
+
+```yaml
+Planning: Default execute immediately | --plan flag→Forces planning mode | --skip-plan→Skip (redundant w/ default)
+MCP Flags: --c7/--no-c7 | --seq/--no-seq | --magic/--no-magic | --pup/--no-pup | --all-mcp | --no-mcp
+Auto-Activation (no flags): /user:build→Magic(UI) if frontend | /user:analyze→Sequential complex | /user:design→Sequential+C7
+/user:explain→C7 if lib mentioned else native | /user:improve→Sequential→C7 | /user:scan→Native only (security)
+Priority: Explicit flags>Auto-activation>Context triggers | --no-mcp overrides all | --no-[server] overrides specific
+Context Share: Sequential→feeds C7 topic selection | C7 docs→inform Magic generation | Magic→tested w/ Puppeteer | All cached
+Execution: Default→Execute immediately | --plan flag→Show plan before changes | User controls→Full control
+```
+
+## Failure Recovery & Best Practices
+
+```yaml
+Failures: C7: Lib not found→broader terms | Docs incomplete→Sequential | API timeout→cache partial+native
+Sequential: Timeout→use partial+note limit | Token limit→summarize+native | Unclear→ask questions+avoid retry
+Magic: No components→try different terms once | Poor quality→refiner w/ context | Integration issues→document+native
+Multi-MCP: Conflict→most reliable source | Resource exhaustion→single best MCP | Partial failures→continue successful only
+
+DO: Match MCP→user need | Set token budgets | Validate before impl | Cache patterns | Graceful fallback
+Use C7 ALL external lib docs (research-first.yml enforced) | Cite MCP sources in impl
+DON'T: MCPs for simple tasks native handles | Chain w/o validation | Exceed 50% context | Retry failed w/o change | MCPs when immediate needed
+OPTIMIZE: Batch similar calls | Reuse session results | Start least expensive | Prefer native file ops | Document successful patterns
+```
+
+---
+*SuperClaude v4.0.0 | Ops MCP instructions for Claude Code intelligence*