claude-code-automation
Version:
🚀 Generic project automation system with anti-compaction protection and recovery capabilities. Automatically detects project type (React, Node.js, Python, Rust, Go, Java) and provides intelligent analysis. Claude Code optimized - run 'welcome' after inst
500 lines (423 loc) • 21.2 kB
JavaScript
/**
* Code Automation - Main Entry Point
* Advanced anti-compaction system with perfect recovery
*/
const fs = require('fs').promises;
const path = require('path');
const { program } = require('commander');
// Import all automation modules
const ContextPreservationEngine = require('./context-preservation');
const AutoRecovery = require('./auto-recovery');
const ContextAnalysis = require('./context-analysis');
const LivePreservationEngine = require('./live-preservation-engine');
const PerfectRecoverySystem = require('./perfect-recovery-system');
const AntiTruncationGuard = require('./anti-truncation-guard');
const CompactionRiskAnalyzer = require('./compaction-risk-analyzer');
const DevelopmentSessionTracker = require('./development-session-tracker');
class ClaudeCodeAutomation {
constructor() {
// Read version dynamically from package.json to avoid hardcoding issues
const packageJson = require('../package.json');
this.version = packageJson.version;
this.projectRoot = process.cwd();
this.automationDir = path.join(this.projectRoot, '.automation');
this.docsDir = path.join(this.projectRoot, '.automation', 'state');
}
/**
* Install automation system in current project
*/
async install() {
// Handle global installation case
if (this.isGlobalInstallation()) {
console.log(`✅ Code Automation v${this.version} installed globally!`);
this.printGlobalUsageInstructions();
return;
}
console.log(`🚀 Installing Code Automation v${this.version}...`);
try {
// Verify we're in a valid project directory or create package.json
if (!await this.isValidProjectDirectory()) {
console.log('📦 No package.json found. Creating basic package.json...');
await this.createBasicPackageJson();
}
// Create directory structure
await this.createDirectoryStructure();
// Copy automation files
await this.copyAutomationFiles();
// Setup package.json scripts
await this.setupPackageScripts();
// Create initial configuration
await this.createConfiguration();
// Initialize context preservation
await this.initializePreservation();
console.log(`✅ Code Automation v${this.version} installed successfully!`);
this.printUsageInstructions();
} catch (error) {
console.error('❌ Installation failed:', error.message);
process.exit(1);
}
}
/**
* Create necessary directory structure
*/
async createDirectoryStructure() {
const dirs = [
'.automation',
'.automation/state',
'.automation/recovery',
'.automation/backups'
];
for (const dir of dirs) {
await fs.mkdir(path.join(this.projectRoot, dir), { recursive: true });
}
}
/**
* Copy automation files to project
*/
async copyAutomationFiles() {
const automationFiles = [
'context-preservation.js',
'auto-recovery.js',
'context-analysis.js',
'daily-automation-cycle.js'
];
// Use templates directory for latest fixed versions
const sourceDir = path.join(__dirname, '../templates/automation');
console.log(`📦 Copying automation files from: ${sourceDir}`);
console.log(`📦 Target directory: ${this.automationDir}`);
let successCount = 0;
for (const file of automationFiles) {
const source = path.join(sourceDir, file);
const target = path.join(this.automationDir, file);
try {
// Check if source file exists first
await fs.access(source);
const content = await fs.readFile(source, 'utf8');
await fs.writeFile(target, content);
console.log(`✅ Copied: ${file}`);
successCount++;
} catch (error) {
console.error(`❌ Failed to copy ${file}: ${error.message}`);
// If we can't copy files, this is a critical error
if (error.code === 'ENOENT') {
console.error(`📁 Source file not found: ${source}`);
console.error(`💡 This suggests a package installation issue.`);
}
}
}
if (successCount === 0) {
throw new Error(`Failed to copy any automation files. Package may be corrupted.`);
} else if (successCount < automationFiles.length) {
console.warn(`⚠️ Warning: Only ${successCount}/${automationFiles.length} files copied successfully.`);
} else {
console.log(`✅ All ${successCount} automation files copied successfully.`);
}
}
/**
* Setup package.json scripts
*/
async setupPackageScripts() {
const packagePath = path.join(this.projectRoot, 'package.json');
try {
const packageContent = await fs.readFile(packagePath, 'utf8');
const packageJson = JSON.parse(packageContent);
if (!packageJson.scripts) {
packageJson.scripts = {};
}
// Add automation scripts (hidden directory)
packageJson.scripts['automation:preserve'] = 'node .automation/context-preservation.js';
packageJson.scripts['automation:recover'] = 'node .automation/auto-recovery.js';
packageJson.scripts['automation:analyze'] = 'node .automation/context-analysis.js';
packageJson.scripts['automation:daily'] = 'node .automation/daily-automation-cycle.js';
packageJson.scripts['automation:guard'] = 'node .automation/anti-truncation-guard.js';
await fs.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
} catch (error) {
console.warn('⚠️ Could not update package.json scripts');
}
}
/**
* Create initial configuration
*/
async createConfiguration() {
const config = {
version: '2.0.0',
enabled: true,
features: {
contextPreservation: true,
antiTruncation: true,
livePreservation: true,
perfectRecovery: true,
riskAnalysis: true,
sessionTracking: true
},
settings: {
preservationInterval: 1800000, // 30 minutes
maxBackups: 50,
compressionEnabled: true,
verboseLogging: false
}
};
await fs.writeFile(
path.join(this.automationDir, 'config.json'),
JSON.stringify(config, null, 2)
);
}
/**
* Initialize context preservation (only for project installation)
*/
async initializePreservation() {
// Skip during global installation
if (this.isGlobalInstallation()) {
console.log('ℹ️ Global installation complete. Use "code-automation install" in your project.');
return;
}
try {
const preservation = new ContextPreservationEngine();
await preservation.preserveCurrentState();
} catch (error) {
// Silently skip - initial preservation is optional during installation
}
}
/**
* Check if this is a global installation context (vs project setup)
*/
isGlobalInstallation() {
// During 'install' command, we're always setting up a project
// This method should check if we're being called during npm install (not user setup)
return false; // Always allow project setup when user runs 'install' command
}
/**
* Check if current directory is a valid project directory
*/
async isValidProjectDirectory() {
try {
// Check for package.json
await fs.access(path.join(this.projectRoot, 'package.json'));
return true;
} catch (error) {
// Check for git repository
try {
await fs.access(path.join(this.projectRoot, '.git'));
return true;
} catch (gitError) {
return false;
}
}
}
/**
* Create basic package.json if it doesn't exist
*/
async createBasicPackageJson() {
const packagePath = path.join(this.projectRoot, 'package.json');
// Check if package.json already exists
try {
await fs.access(packagePath);
console.log('📦 Found existing package.json');
return; // Don't overwrite existing package.json
} catch (error) {
// File doesn't exist, create it
const projectName = path.basename(this.projectRoot);
const basicPackage = {
"name": projectName,
"version": "1.0.0",
"description": "Project with Code Automation",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC"
};
await fs.writeFile(packagePath, JSON.stringify(basicPackage, null, 2));
console.log('✅ Created basic package.json');
}
}
/**
* Print usage instructions for project installation
*/
printUsageInstructions() {
console.log('\n🎯 Quick Start Guide:');
console.log('┌─────────────────────────────────────────────────────┐');
console.log('│ Basic Commands │');
console.log('├─────────────────────────────────────────────────────┤');
console.log('│ npm run automation:preserve - Save current state │');
console.log('│ npm run automation:analyze - Check project health│');
console.log('│ npm run automation:recover - Restore from backup │');
console.log('│ npm run automation:daily - Run full cycle │');
console.log('└─────────────────────────────────────────────────────┘');
console.log('\n🛡️ Anti-Compaction Protection:');
console.log('✅ Auto-saves every 30 minutes');
console.log('✅ Perfect recovery guarantee');
console.log('✅ Real-time context monitoring');
console.log('\n🚀 Next Steps:');
console.log('1. Start protection: npm run automation:preserve');
console.log('2. Continue your work normally');
console.log('3. If context is lost: npm run automation:recover');
console.log('\n📚 Files created:');
console.log('• scripts/automation/ - Automation scripts');
console.log('• docs/state/ - Project backups');
console.log('• docs/recovery/ - Recovery instructions');
console.log('\n💡 Pro Tip: Run "npm run automation:daily" for maintenance');
}
/**
* Print usage instructions for global installation
*/
printGlobalUsageInstructions() {
console.log('\n🌍 Global Installation Complete!');
console.log('┌─────────────────────────────────────────────────────┐');
console.log('│ Setup Your Project │');
console.log('├─────────────────────────────────────────────────────┤');
console.log('│ 1. cd your-project │');
console.log('│ 2. code-automation install │');
console.log('│ 3. npm run automation:preserve │');
console.log('└─────────────────────────────────────────────────────┘');
console.log('\n⚡ Global Commands Available:');
console.log('• code-automation install - Setup current project');
console.log('• preserve - Quick context save');
console.log('• recover - Emergency recovery');
console.log('• analyze - Project health check');
console.log('\n🎯 Common Workflows:');
console.log('┌─────────────────────────────────────────────────────┐');
console.log('│ New Project Setup: │');
console.log('│ cd my-new-project │');
console.log('│ code-automation install │');
console.log('│ │');
console.log('│ Existing Project: │');
console.log('│ cd existing-project │');
console.log('│ preserve │');
console.log('│ │');
console.log('│ Lost Context? │');
console.log('│ recover │');
console.log('└─────────────────────────────────────────────────────┘');
console.log('\n🔧 Need Help?');
console.log('• code-automation --help - Show all commands');
console.log('• code-automation --version - Check version');
console.log('\n💡 Pro Tip: Works with any project type (React, Node.js, Python, etc.)');
}
/**
* Show welcome message if this is likely first use
*/
showWelcomeIfNeeded() {
// Don't show welcome here - it's handled by the binary
}
/**
* Show detailed help information
*/
showDetailedHelp() {
console.log(`\n🎯 Code Automation v${this.version} - Complete Guide`);
console.log('═══════════════════════════════════════════════════════');
console.log('\n📦 Installation:');
console.log(' npm install -g claude-code-automation # Global install');
console.log(' npm install claude-code-automation --save-dev # Project install');
console.log('\n🚀 Quick Setup:');
console.log(' cd your-project');
console.log(' code-automation install # Setup project');
console.log(' npm run automation:preserve # Start protection');
console.log('\n⚡ Available Commands:');
console.log('┌─────────────────────────────────────────────────────┐');
console.log('│ Command │ Description │');
console.log('├─────────────────────────────────────────────────────┤');
console.log('│ code-automation install │ Setup current project │');
console.log('│ preserve │ Save project state │');
console.log('│ recover │ Restore from backup │');
console.log('│ analyze │ Check project health │');
console.log('│ code-automation help │ Show this guide │');
console.log('└─────────────────────────────────────────────────────┘');
console.log('\n🎯 Use Cases:');
console.log('• Before long coding sessions');
console.log('• When working on complex features');
console.log('• After major architectural changes');
console.log('• When switching between tasks');
console.log('\n🛡️ What It Protects:');
console.log('✅ Project structure and files');
console.log('✅ Development progress');
console.log('✅ Architecture decisions');
console.log('✅ Context and conversations');
console.log('\n🔧 Troubleshooting:');
console.log('• Context lost? → recover');
console.log('• Need project status? → analyze');
console.log('• Setup issues? → code-automation install');
console.log('\n📚 Learn More:');
console.log('• NPM: https://npmjs.com/package/claude-code-automation');
}
/**
* Command line interface
*/
setupCLI() {
// Show welcome message on first CLI interaction
this.showWelcomeIfNeeded();
program
.name('code-automation')
.description(`Code Automation v${this.version} - Advanced anti-compaction system`)
.version(this.version)
.option('-v, --verbose', 'Enable verbose output')
.option('-q, --quiet', 'Suppress non-essential output');
program
.command('install')
.description('Install automation system in current project')
.action(() => this.install());
program
.command('help')
.description('Show detailed usage instructions')
.action(() => this.showDetailedHelp());
program
.command('preserve')
.description('Preserve current project context')
.action(async () => {
const verboseMode = program.opts().verbose;
if (verboseMode) {
console.log('🔄 Starting context preservation in verbose mode...');
}
const preservation = new ContextPreservationEngine();
await preservation.preserveCurrentState();
if (verboseMode) {
console.log('✅ Context preservation completed successfully');
}
});
program
.command('recover')
.description('Recover project from latest backup')
.action(async () => {
const verboseMode = program.opts().verbose;
if (verboseMode) {
console.log('🔄 Starting project recovery in verbose mode...');
}
const recovery = new AutoRecovery();
await recovery.recoverFromLatest();
if (verboseMode) {
console.log('✅ Project recovery completed successfully');
}
});
program
.command('analyze')
.description('Analyze current project state')
.action(async () => {
const verboseMode = program.opts().verbose;
if (verboseMode) {
console.log('🔄 Starting project analysis in verbose mode...');
}
const analysis = new ContextAnalysis();
await analysis.analyzeCurrentContext();
if (verboseMode) {
console.log('✅ Project analysis completed successfully');
}
});
program
.command('guard')
.description('Start anti-truncation guard')
.action(async () => {
const guard = new AntiTruncationGuard();
await guard.startGuarding();
});
program.parse();
}
}
// Export for use as module
module.exports = ClaudeCodeAutomation;
// Run CLI if called directly
if (require.main === module) {
const automation = new ClaudeCodeAutomation();
automation.setupCLI();
}