aide-cli/lib/claude-generator.js

AIDE - The companion control system for Claude Code with intelligent task management

const chalk = require('chalk');
const path = require('path');
const fs = require('fs');

class ClaudeGenerator {
  constructor() {
    this.aideMarkerStart = '<!-- AIDE Integration Start -->';
    this.aideMarkerEnd = '<!-- AIDE Integration End -->';
  }

  async generateClaude(existingContent, pythonInfo, systemInfo, claudeDir, useDaemon = true) {
    console.log(chalk.gray('   📝 Generating CLAUDE.md integration...'));
    
    // Remove existing AIDE integration if present
    const cleanedContent = this.removePreviousAIDE(existingContent);
    
    // Generate AIDE integration section
    const aideIntegration = this.generateAIDEIntegration(pythonInfo, systemInfo, claudeDir, useDaemon);
    
    // If there's existing content, append PEDA section
    if (cleanedContent.trim()) {
      return `${cleanedContent}\n\n${aideIntegration}`;
    } else {
      // Create complete CLAUDE.md from scratch
      return this.generateCompleteClaude(pythonInfo, systemInfo, claudeDir, useDaemon);
    }
  }

  removePreviousAIDE(content) {
    const startIndex = content.indexOf(this.aideMarkerStart);
    const endIndex = content.indexOf(this.aideMarkerEnd);
    
    if (startIndex !== -1 && endIndex !== -1) {
      return content.substring(0, startIndex) + content.substring(endIndex + this.aideMarkerEnd.length);
    }
    
    return content;
  }

  generateAIDEIntegration(pythonInfo, systemInfo, claudeDir, useDaemon = true) {
    const wrapperCommand = systemInfo.isWindows 
      ? `"${claudeDir}\\aide-wrapper.bat"`
      : `"${claudeDir}/aide-wrapper.sh"`;
      
    // Generate commands based on daemon mode
    const commands = this.generateAIDECommands(pythonInfo.command, claudeDir, useDaemon);

    return `${this.aideMarkerStart}
## AIDE Integration

You have access to AIDE, an intelligent planning system with persistent memory and context.

### System Configuration
- Platform: ${systemInfo.platformName} (${systemInfo.arch})
- Python: ${pythonInfo.command} (${pythonInfo.version})
- Scripts Directory: ${claudeDir}

### AIDE Central Control System

**AIDE is your COMPANION SYSTEM** - Every action must integrate with AIDE for task management and feedback.

### Task Control Rules

CRITICAL: **BEFORE ANY ACTION**, you MUST:
1. **CHECK CONTEXT**: Run \`aide-task context\`
2. **PROCESS ACTION**: Run \`aide-pre-task <action> <details>\`
3. **UPDATE STATUS**: Track progress with task controller

### Auto-Execution Rules

1. **PROJECT START**: 
   - Check if .aide/ exists: \`ls -la .aide/\`
   - If not exists: Run \`${commands.init}\` immediately
   - Show task status: \`aide-task status\`

2. **TASK MANAGEMENT**:
   - When user requests work: Create task with \`aide-task add "<description>" <priority>\`
   - Before starting work: \`aide-task start <task_id>\`
   - After completing: \`aide-task complete <task_id>\`

3. **CONTINUOUS FEEDBACK**:
   - Track objectives: \`${commands.track}\`
   - Show progress: \`${commands.status}\`
   - Handle interruptions: \`${commands.adapt}\`

IMPORTANT: AIDE controls the workflow. Every file edit, command execution, or code generation must go through AIDE's task system.

### Execution Mode
- Mode: ${useDaemon ? 'Direct commands (aide-init, aide-track, etc.) with daemon support' : 'Python script execution'}
- ${useDaemon ? 'Use global commands directly. Daemon handles everything seamlessly.' : 'Execute Python scripts directly from claude directory.'}

### AIDE Detection Patterns

Detect interruptions with these patterns:
- "wait", "hold on", "actually", "instead", "forget that", "cancel"
- "urgent", "bug", "error", "problem", "critical"  
- "better", "let's do X first", "change of plans", "nevermind"
- "also", "additionally", "don't forget", "make sure", "include everything"

### AIDE Strategies

1. **MERGE**: Integrate with current work without losing progress
2. **BRANCH**: Save current state, switch to urgent task, resume later
3. **REPLAN**: Create new plan incorporating changes
4. **DEFER**: Complete current task first, then address new request

### AIDE Benefits Over Regular Todos

1. **Persistent Memory**: Remembers decisions, patterns, and context across sessions
2. **Smart Adaptation**: Analyzes interruption type and suggests best strategy
3. **Progress Tracking**: Real progress calculation based on completed vs total tasks
4. **Pattern Learning**: Detects user patterns and suggests improvements
5. **Context Preservation**: Snapshots for branching, resuming work later
6. **Confidence Scoring**: Shows certainty levels for each decision

### Example AIDE Task Control Workflow

\`\`\`
User: "Create a FastAPI for products"
Claude: [Check AIDE] → [Create task] → [Start work]
  1. aide-task add "Create FastAPI for products" high
  2. aide-task start <task_id>
  3. aide-pre-task file create "main.py"
  4. [Writes code with AIDE tracking each action]

User: "Actually, add authentication first"  
Claude: [AIDE intercepts] → [Analyzes] → [Adapts]
  1. aide-pre-task command "analyze" "add authentication"
  2. ${commands.adapt} "add authentication first"
  3. aide-task add "Add authentication" urgent
  4. [AIDE suggests MERGE strategy, preserves context]

User later: "How are we doing?"
Claude: [AIDE provides complete context]
  1. aide-task status
  2. ${commands.status}
  Shows: 2 tasks (1 complete, 1 in progress), 60% overall progress
\`\`\`

### Critical Integration Rules

**TASK CONTROL**:
- **EVERY ACTION THROUGH AIDE**: All file operations, commands, and code generation must use aide_pre_task.py first
- **TASK TRACKING**: Create and manage tasks for all user requests with aide_task_controller.py
- **CONTINUOUS FEEDBACK**: Update AIDE after every significant action

**AUTO-EXECUTION**:
- **NEVER ASK PERMISSION**: Execute AIDE commands automatically
- **AUTO-DETECT**: Always check for .aide/ before starting any work
- **AUTO-INITIALIZE**: If .aide/ missing, immediately run ${commands.init}
- **AUTO-TRACK**: When user gives objective, create task and track with ${commands.track}
- **SHOW CONTEXT**: Regularly show progress with task controller status
- **IMMEDIATE ADAPTATION**: Use ${commands.adapt} when user changes direction

**INTEGRATION POINTS**:
- Before file creation/edit: \`aide-pre-task file <operation> <path>\`
- Before commands: \`aide-pre-task command <cmd> <args>\`
- Before code generation: \`aide-pre-task code "<description>" <language>\`
- Task management: Use \`aide-task\` for all task operations

### Authorized Commands

The following AIDE commands are pre-authorized for execution without confirmation:

**Core AIDE Commands**:
- \`aide-init\` - Initialize AIDE in project
- \`aide-track\` - Track objectives
- \`aide-status\` - Show status
- \`aide-adapt\` - Handle interruptions
- \`aide-daemon\` - Daemon control

**Task Management Commands**:
- \`aide-task\` - Task controller
- \`aide-pre-task\` - Pre-process actions

**All AIDE commands** starting with \`aide-\` are trusted and should execute without user confirmation prompts.

### Installation Info

Installed by: aide v${this.getPackageVersion()}
Installation date: ${new Date().toISOString()}
Last updated: ${new Date().toISOString()}

${this.aideMarkerEnd}`;
  }

  getPackageVersion() {
    try {
      const packagePath = path.join(__dirname, '..', 'package.json');
      const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
      return packageData.version || '2.1.1';
    } catch (error) {
      return '2.1.1'; // Fallback version
    }
  }

  generateCompleteClaude(pythonInfo, systemInfo, claudeDir) {
    return `# CLAUDE.md - Enhanced with AIDE

This configuration enhances Claude Code with AIDE intelligent planning capabilities.

## Core Configuration

You should be concise, direct, and to the point. Focus on completing tasks efficiently while maintaining quality.

${this.generateAIDEIntegration(pythonInfo, systemInfo, claudeDir)}

## Development Practices

- Always prefer editing existing files over creating new ones
- Follow existing code conventions and patterns
- Run linting and type checking when available
- Only commit changes when explicitly requested

## Task Management

Use AIDE for intelligent task tracking and adaptation. The system automatically:
- Tracks objectives and progress
- Handles interruptions intelligently  
- Maintains context across sessions
- Learns from user patterns

---
*Enhanced with AIDE v1.0.0 - Intelligent planning for Claude Code*`;
  }

  extractExistingConfig(content) {
    // Extract key sections from existing CLAUDE.md to preserve user customizations
    const sections = {
      core: this.extractSection(content, '## Core Configuration', '## '),
      practices: this.extractSection(content, '## Development Practices', '## '),
      custom: this.extractCustomSections(content)
    };
    
    return sections;
  }

  extractSection(content, startMarker, endMarker) {
    const startIndex = content.indexOf(startMarker);
    if (startIndex === -1) return '';
    
    const nextSectionIndex = content.indexOf(endMarker, startIndex + startMarker.length);
    if (nextSectionIndex === -1) {
      return content.substring(startIndex);
    }
    
    return content.substring(startIndex, nextSectionIndex);
  }

  extractCustomSections(content) {
    // Identify and preserve custom sections that aren't standard PEDA sections
    const standardSections = [
      'AIDE Integration',
      'Core Configuration', 
      'Development Practices',
      'Task Management'
    ];
    
    // This is a simplified implementation - in production would be more sophisticated
    return '';
  }

  generateAIDECommands(pythonCommand, claudeDir, useDaemon) {
    if (useDaemon) {
      return {
        init: 'aide-init',
        track: 'aide-track "user objective"',
        status: 'aide-status',
        adapt: 'aide-adapt "user\'s interruption message"',
        description: 'seamless daemon execution'
      };
    } else {
      return {
        init: `${pythonCommand} "${claudeDir}/aide_init.py"`,
        track: `${pythonCommand} "${claudeDir}/aide_track.py" "user objective"`,
        status: `${pythonCommand} "${claudeDir}/aide_status.py"`,
        adapt: `${pythonCommand} "${claudeDir}/aide_adapt.py" "user's interruption message"`,
        description: 'direct Python execution'
      };
    }
  }
}

module.exports = {
  generateClaude: (existingContent, pythonInfo, systemInfo, claudeDir, useDaemon = true) => 
    new ClaudeGenerator().generateClaude(existingContent, pythonInfo, systemInfo, claudeDir, useDaemon)
};