nx-claude-sessions-intelligence/manual-init.js

The first NX-native intelligent AI development orchestration system with persistent decision storage, pattern recognition, and cross-session knowledge accumulation. Transform forgetful Claude sessions into intelligent, context-aware development workflows.

#!/usr/bin/env node

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

/**
 * Manual Initialization for nx-claude-sessions-intelligence
 * 
 * This script bypasses NX generators and manually sets up intelligent session management
 * when NX lockfile parsing fails.
 */

async function manualInit() {
  console.log('🧠 Manual Initialization: nx-claude-sessions-intelligence');
  console.log('================================================');
  console.log('');

  try {
    // Check if we're in an NX workspace
    const nxJsonPath = path.join(process.cwd(), 'nx.json');
    if (!fs.existsSync(nxJsonPath)) {
      console.error('❌ Not an NX workspace - nx.json not found');
      process.exit(1);
    }

    console.log('✅ NX workspace detected');

    // 1. Update nx.json with plugin configuration
    await updateNxConfig();

    // 2. Create .claude directories for existing libraries
    await setupClaudeDirectories();

    // 3. Create session storage directory
    await setupSessionStorage();

    // 4. Update .gitignore
    await updateGitignore();

    console.log('');
    console.log('🎉 Manual initialization complete!');
    console.log('');
    console.log('📋 Next Steps:');
    console.log('1. Install MCP server: npm install -g claude-session-intelligence-mcp@latest');
    console.log('2. Configure Claude Desktop (see documentation)');
    console.log('3. Start your first intelligent session:');
    console.log('   npx nx start-claude-session <library> --task="Your task"');
    console.log('');

  } catch (error) {
    console.error('❌ Manual initialization failed:', error.message);
    console.log('');
    console.log('🛠️ Manual steps to complete setup:');
    console.log('1. Add to nx.json:');
    console.log(JSON.stringify({
      plugins: [{
        plugin: "nx-claude-sessions-intelligence",
        options: {
          maxConcurrency: 5,
          sessionTimeout: "30m",
          orchestrationStrategy: "dependency-aware"
        }
      }]
    }, null, 2));
    console.log('');
    console.log('2. Create .claude directories in each library');
    console.log('3. Install MCP server globally');
    
    process.exit(1);
  }
}

async function updateNxConfig() {
  console.log('📝 Updating nx.json configuration...');
  
  const nxJsonPath = path.join(process.cwd(), 'nx.json');
  let nxConfig;
  
  try {
    const content = fs.readFileSync(nxJsonPath, 'utf-8');
    nxConfig = JSON.parse(content);
  } catch (error) {
    throw new Error(`Failed to read nx.json: ${error.message}`);
  }

  // Initialize plugins array if it doesn't exist
  if (!nxConfig.plugins) {
    nxConfig.plugins = [];
  }

  // Check if plugin is already configured
  const existingPlugin = nxConfig.plugins.find(p => 
    p === 'nx-claude-sessions-intelligence' || 
    (typeof p === 'object' && p.plugin === 'nx-claude-sessions-intelligence')
  );

  if (existingPlugin) {
    console.log('  ⚠️  Plugin already configured in nx.json');
  } else {
    // Add plugin configuration
    nxConfig.plugins.push({
      plugin: 'nx-claude-sessions-intelligence',
      options: {
        maxConcurrency: 5,
        sessionTimeout: '30m',
        orchestrationStrategy: 'dependency-aware',
        autoTransitions: {
          enabled: true,
          crossLibraryThreshold: 3,
          topicShiftConfidence: 0.7
        }
      }
    });

    // Write back to nx.json
    fs.writeFileSync(nxJsonPath, JSON.stringify(nxConfig, null, 2) + '\n');
    console.log('  ✅ Plugin configuration added to nx.json');
  }
}

async function setupClaudeDirectories() {
  console.log('📁 Setting up .claude directories...');
  
  const dirsToCheck = ['libs', 'packages', 'apps'];
  let librariesFound = 0;

  for (const dir of dirsToCheck) {
    const dirPath = path.join(process.cwd(), dir);
    if (fs.existsSync(dirPath)) {
      const entries = fs.readdirSync(dirPath);
      
      for (const entry of entries) {
        const entryPath = path.join(dirPath, entry);
        const stat = fs.statSync(entryPath);
        
        if (stat.isDirectory()) {
          await createClaudeDirectory(entry, entryPath);
          librariesFound++;
        }
      }
    }
  }

  console.log(`  ✅ Created .claude directories for ${librariesFound} libraries`);
}

async function createClaudeDirectory(libraryName, libraryPath) {
  const claudeDir = path.join(libraryPath, '.claude');
  
  if (!fs.existsSync(claudeDir)) {
    fs.mkdirSync(claudeDir, { recursive: true });
  }

  // Create context.md
  const contextFile = path.join(claudeDir, 'context.md');
  if (!fs.existsSync(contextFile)) {
    const contextContent = `# ${libraryName} Library Context

## Purpose
[Describe what this library does]

## Architecture  
[Key architectural patterns and design decisions]

## Dependencies
- [List key dependencies and their purposes]

## Established Patterns
- [Document coding conventions and patterns]

## Integration Points
- [How this library integrates with others]

## Known Issues & Solutions
- [Common problems and their solutions]

## Testing Strategy
- [How this library should be tested]
`;
    fs.writeFileSync(contextFile, contextContent);
  }

  // Create empty JSON files
  const files = [
    { name: 'decisions.json', content: { decisions: [] } },
    { name: 'patterns.json', content: { patterns: [] } },
    { name: 'session-history.json', content: { sessions: [] } },
    { name: 'dependencies.json', content: {} }
  ];

  for (const file of files) {
    const filePath = path.join(claudeDir, file.name);
    if (!fs.existsSync(filePath)) {
      fs.writeFileSync(filePath, JSON.stringify(file.content, null, 2));
    }
  }

  // Create metadata
  const metaFile = path.join(claudeDir, 'meta.json');
  if (!fs.existsSync(metaFile)) {
    const meta = {
      library_name: libraryName,
      intelligence_version: '1.0.0',
      created: new Date().toISOString(),
      last_updated: new Date().toISOString(),
      session_count: 0,
      decision_count: 0,
      pattern_count: 0,
      maturity_level: 'experimental',
      expertise_areas: [],
      complexity_metrics: {
        files_managed: 0,
        dependency_depth: 0,
        pattern_reuse: 0.0
      }
    };
    fs.writeFileSync(metaFile, JSON.stringify(meta, null, 2));
  }
}

async function setupSessionStorage() {
  console.log('🗄️  Setting up session storage...');
  
  const sessionDir = path.join(process.cwd(), '.nx-claude-sessions');
  const subdirs = ['active', 'archives', 'coordination'];

  for (const subdir of subdirs) {
    const dirPath = path.join(sessionDir, subdir);
    if (!fs.existsSync(dirPath)) {
      fs.mkdirSync(dirPath, { recursive: true });
    }
  }

  console.log('  ✅ Session storage directories created');
}

async function updateGitignore() {
  console.log('📝 Updating .gitignore...');
  
  const gitignorePath = path.join(process.cwd(), '.gitignore');
  const linesToAdd = [
    '',
    '# Claude Session Intelligence',
    '.nx-claude-sessions/active/',
    '.nx-claude-sessions/coordination/'
  ];

  let gitignoreContent = '';
  if (fs.existsSync(gitignorePath)) {
    gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
  }

  // Check if lines are already present
  const hasIntelligenceSection = gitignoreContent.includes('Claude Session Intelligence');
  
  if (!hasIntelligenceSection) {
    gitignoreContent += linesToAdd.join('\n') + '\n';
    fs.writeFileSync(gitignorePath, gitignoreContent);
    console.log('  ✅ .gitignore updated');
  } else {
    console.log('  ⚠️  .gitignore already configured');
  }
}

// Run if called directly
if (require.main === module) {
  manualInit().catch(error => {
    console.error('Fatal error:', error);
    process.exit(1);
  });
}

module.exports = { manualInit };