@diagramers/cli 1.0.6

package/src/commands/init.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { ProjectInitializer } from '../services/project-initializer';
+import chalk from 'chalk';
+
+export function initCommand(program: Command) {
+  program
+    .command('init <project-name>')
+    .description('Initialize a new project from the template')
+    .option('-t, --template <template>', 'Template version to use', 'latest')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(async (projectName: string, options: any) => {
+      try {
+        console.log(chalk.blue(`🚀 Initializing new project: ${projectName}`));
+        
+        const initializer = new ProjectInitializer();
+        await initializer.initialize(projectName, options);
+        
+        console.log(chalk.green(`✅ Project ${projectName} initialized successfully!`));
+        console.log(chalk.yellow(`📁 Navigate to the project: cd ${projectName}`));
+        console.log(chalk.yellow(`🔧 Install dependencies: npm install`));
+        console.log(chalk.yellow(`🚀 Start development: npm run serve`));
+      } catch (error: any) {
+        console.error(chalk.red(`❌ Failed to initialize project: ${error.message}`));
+        process.exit(1);
+      }
+    });
+} 

package/src/commands/update.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { ProjectUpdater } from '../services/project-updater';
+import chalk from 'chalk';
+
+export function updateCommand(program: Command) {
+  program
+    .command('update')
+    .description('Update existing project with latest template features')
+    .option('-f, --force', 'Force update even if conflicts detected')
+    .option('-b, --backup', 'Create backup before updating')
+    .action(async (options: any) => {
+      try {
+        console.log(chalk.blue('🔄 Checking for template updates...'));
+        
+        const updater = new ProjectUpdater();
+        await updater.update(options);
+        
+        console.log(chalk.green('✅ Project updated successfully!'));
+        console.log(chalk.yellow('📝 Review the changes and test your application'));
+      } catch (error: any) {
+        console.error(chalk.red(`❌ Failed to update project: ${error.message}`));
+        process.exit(1);
+      }
+    });
+} 

package/src/config/template-config.ts

@@ -0,0 +1,111 @@
+export interface TemplateConfig {
+  name: string;
+  version: string;
+  description: string;
+  files: {
+    include: string[];
+    exclude: string[];
+    updateable: string[];
+    customizable: string[];
+  };
+  features: {
+    [key: string]: {
+      name: string;
+      description: string;
+      dependencies: string[];
+      files: string[];
+    };
+  };
+}
+
+export const templateConfig: TemplateConfig = {
+  name: 'diagrammers-api-template',
+  version: '1.0.0',
+  description: 'Node.js API template with TypeScript, Firebase Functions, and Socket.io',
+  
+  files: {
+    include: [
+      'src/**/*',
+      'package.json',
+      'tsconfig.json',
+      'webpack.config.js',
+      'main.ts',
+      'certs/**/*'
+    ],
+    exclude: [
+      'node_modules/**',
+      'dist/**',
+      'cli/**',
+      '.git/**',
+      'backup-*/**',
+      '*.log',
+      '.env*'
+    ],
+    updateable: [
+      'src/helpers/**/*',
+      'src/config/**/*',
+      'src/server/**/*',
+      'webpack.config.js',
+      'tsconfig.json'
+    ],
+    customizable: [
+      'src/controllers/**/*',
+      'src/entities/**/*',
+      'src/routes/**/*',
+      'src/services/**/*',
+      'src/schemas/**/*',
+      'main.ts'
+    ]
+  },
+  
+  features: {
+    auth: {
+      name: 'Authentication',
+      description: 'JWT-based authentication system',
+      dependencies: ['jsonwebtoken', 'bcryptjs', '@types/jsonwebtoken', '@types/bcryptjs'],
+      files: [
+        'src/features/auth/**/*',
+        'src/helpers/auth.ts'
+      ]
+    },
+    email: {
+      name: 'Email System',
+      description: 'Email notification system with templates',
+      dependencies: ['nodemailer', 'handlebars', '@types/nodemailer'],
+      files: [
+        'src/features/email/**/*',
+        'src/helpers/mailer.ts',
+        'src/assets/css/email-template.css'
+      ]
+    },
+    socket: {
+      name: 'WebSocket',
+      description: 'Real-time communication with Socket.io',
+      dependencies: ['socket.io', '@types/socket.io'],
+      files: [
+        'src/features/socket/**/*',
+        'src/server/socket-server-provider.ts'
+      ]
+    },
+    cron: {
+      name: 'Scheduled Tasks',
+      description: 'Cron job system for scheduled tasks',
+      dependencies: ['node-cron', '@types/node-cron'],
+      files: [
+        'src/features/cron/**/*',
+        'src/helpers/cronHelper.ts'
+      ]
+    },
+    audit: {
+      name: 'Audit Logging',
+      description: 'Comprehensive audit logging system',
+      dependencies: [],
+      files: [
+        'src/features/audit/**/*',
+        'src/entities/audit.ts',
+        'src/schemas/audit.ts',
+        'src/services/audit-service.ts'
+      ]
+    }
+  }
+}; 

package/src/index.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { initCommand } from './commands/init';
+import { updateCommand } from './commands/update';
+import { extendCommand } from './commands/extend';
+import chalk from 'chalk';
+
+const program = new Command();
+
+program
+  .name('diagrammers')
+  .description('CLI tool for managing Diagrammers projects')
+  .version('1.0.0');
+
+// Add commands
+initCommand(program);
+updateCommand(program);
+extendCommand(program);
+
+// Add help text
+program.addHelpText('after', `
+Examples:
+  $ diagrammers init api my-new-project
+  $ diagrammers init admin my-admin-dashboard
+  $ diagrammers update
+  $ diagrammers extend --feature auth
+`);
+
+program.parse();
+
+// If no command is provided, show help
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+} 

package/src/services/project-extender.ts

@@ -0,0 +1,196 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import chalk from 'chalk';
+
+export interface Feature {
+  name: string;
+  description: string;
+  files: string[];
+  dependencies?: string[];
+}
+
+export class ProjectExtender {
+  private features: Feature[] = [
+    {
+      name: 'auth',
+      description: 'Authentication system with JWT',
+      files: ['src/features/auth/**/*'],
+      dependencies: ['jsonwebtoken', 'bcryptjs']
+    },
+    {
+      name: 'email',
+      description: 'Email notification system',
+      files: ['src/features/email/**/*'],
+      dependencies: ['nodemailer', 'handlebars']
+    },
+    {
+      name: 'socket',
+      description: 'Real-time WebSocket communication',
+      files: ['src/features/socket/**/*'],
+      dependencies: ['socket.io']
+    },
+    {
+      name: 'cron',
+      description: 'Scheduled task system',
+      files: ['src/features/cron/**/*'],
+      dependencies: ['node-cron']
+    },
+    {
+      name: 'audit',
+      description: 'Audit logging system',
+      files: ['src/features/audit/**/*']
+    }
+  ];
+
+  async listFeatures(): Promise<void> {
+    console.log(chalk.blue('📋 Available features:'));
+    console.log('');
+    
+    this.features.forEach(feature => {
+      console.log(chalk.green(`  ${feature.name}`));
+      console.log(chalk.gray(`    ${feature.description}`));
+      if (feature.dependencies && feature.dependencies.length > 0) {
+        console.log(chalk.yellow(`    Dependencies: ${feature.dependencies.join(', ')}`));
+      }
+      console.log('');
+    });
+  }
+
+  async addFeature(featureName: string): Promise<void> {
+    const feature = this.features.find(f => f.name === featureName);
+    
+    if (!feature) {
+      throw new Error(`Feature '${featureName}' not found. Use --list to see available features.`);
+    }
+
+    const projectPath = process.cwd();
+    
+    // Check if feature already exists
+    const featurePath = path.join(projectPath, 'src', 'features', featureName);
+    if (await fs.pathExists(featurePath)) {
+      throw new Error(`Feature '${featureName}' already exists in this project.`);
+    }
+
+    // Create feature directory structure
+    await this.createFeatureStructure(projectPath, feature);
+
+    // Add dependencies if any
+    if (feature.dependencies && feature.dependencies.length > 0) {
+      await this.addDependencies(feature.dependencies);
+    }
+
+    console.log(chalk.green(`✅ Feature '${featureName}' added successfully!`));
+  }
+
+  private async createFeatureStructure(projectPath: string, feature: Feature): Promise<void> {
+    const featurePath = path.join(projectPath, 'src', 'features', feature.name);
+    
+    // Create basic feature structure
+    const structure = {
+      'controllers': 'Feature controllers',
+      'services': 'Feature business logic',
+      'schemas': 'Feature validation schemas',
+      'routes': 'Feature API routes',
+      'types': 'Feature TypeScript types'
+    };
+
+    for (const [dir, description] of Object.entries(structure)) {
+      const dirPath = path.join(featurePath, dir);
+      await fs.ensureDir(dirPath);
+      
+      // Create index file
+      const indexContent = `// ${description} for ${feature.name} feature
+export * from './${feature.name}-${dir.slice(0, -1)}';
+`;
+      await fs.writeFile(path.join(dirPath, 'index.ts'), indexContent);
+    }
+
+    // Create main feature file
+    const mainFeatureContent = `import { Router } from 'express';
+import { ${feature.name}Controller } from './controllers';
+import { ${feature.name}Service } from './services';
+
+export class ${this.capitalizeFirst(feature.name)}Feature {
+  private router: Router;
+  private controller: ${feature.name}Controller;
+  private service: ${feature.name}Service;
+
+  constructor() {
+    this.router = Router();
+    this.service = new ${feature.name}Service();
+    this.controller = new ${feature.name}Controller(this.service);
+    this.setupRoutes();
+  }
+
+  private setupRoutes(): void {
+    // Define your routes here
+    // this.router.get('/', this.controller.index.bind(this.controller));
+  }
+
+  public getRouter(): Router {
+    return this.router;
+  }
+}
+`;
+    
+    await fs.writeFile(path.join(featurePath, `${feature.name}.ts`), mainFeatureContent);
+
+    // Create controller
+    const controllerContent = `import { Request, Response } from 'express';
+import { ${feature.name}Service } from '../services';
+
+export class ${feature.name}Controller {
+  constructor(private service: ${feature.name}Service) {}
+
+  // Add your controller methods here
+  // async index(req: Request, res: Response): Promise<void> {
+  //   try {
+  //     const result = await this.service.someMethod();
+  //     res.json(result);
+  //   } catch (error) {
+  //     res.status(500).json({ error: error.message });
+  //   }
+  // }
+}
+`;
+    
+    await fs.writeFile(path.join(featurePath, 'controllers', `${feature.name}-controller.ts`), controllerContent);
+
+    // Create service
+    const serviceContent = `export class ${feature.name}Service {
+  // Add your service methods here
+  // async someMethod(): Promise<any> {
+  //   // Implementation
+  // }
+}
+`;
+    
+    await fs.writeFile(path.join(featurePath, 'services', `${feature.name}-service.ts`), serviceContent);
+
+    // Create types
+    const typesContent = `// TypeScript types for ${feature.name} feature
+export interface ${this.capitalizeFirst(feature.name)}Config {
+  // Add configuration interface
+}
+
+export interface ${this.capitalizeFirst(feature.name)}Data {
+  // Add data interface
+}
+`;
+    
+    await fs.writeFile(path.join(featurePath, 'types', `${feature.name}-types.ts`), typesContent);
+  }
+
+  private async addDependencies(dependencies: string[]): Promise<void> {
+    console.log(chalk.blue('📦 Installing dependencies...'));
+    
+    // This would typically run npm install with the dependencies
+    // For now, we'll just log what would be installed
+    console.log(chalk.yellow(`Would install: ${dependencies.join(', ')}`));
+    console.log(chalk.gray('Run: npm install ' + dependencies.join(' ') + ' to install dependencies'));
+  }
+
+  private capitalizeFirst(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+} 

package/src/services/project-initializer.ts

@@ -0,0 +1,224 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as glob from 'glob';
+import chalk from 'chalk';
+
+export interface InitOptions {
+  template?: string;
+  yes?: boolean;
+}
+
+export class ProjectInitializer {
+  private templatePath: string;
+  private templateFiles: string[] = [
+    'src/**/*',
+    'package.json',
+    'tsconfig.json',
+    'webpack.config.js',
+    'main.ts',
+    'certs/**/*'
+  ];
+
+  constructor() {
+    // Get the path to the template (parent directory of CLI)
+    this.templatePath = path.resolve(__dirname, '../../..');
+  }
+
+  async initialize(projectName: string, options: InitOptions): Promise<void> {
+    const projectPath = path.resolve(process.cwd(), projectName);
+
+    // Check if project directory already exists
+    if (await fs.pathExists(projectPath)) {
+      throw new Error(`Project directory ${projectName} already exists`);
+    }
+
+    // Create project directory
+    await fs.ensureDir(projectPath);
+
+    // Copy template files
+    await this.copyTemplateFiles(projectPath);
+
+    // Update package.json with project name
+    await this.updatePackageJson(projectPath, projectName);
+
+    // Create .gitignore
+    await this.createGitignore(projectPath);
+
+    // Create README
+    await this.createReadme(projectPath, projectName);
+
+    console.log(chalk.green(`✅ Project structure created successfully`));
+  }
+
+  private async copyTemplateFiles(projectPath: string): Promise<void> {
+    for (const pattern of this.templateFiles) {
+      try {
+        const files = glob.sync(pattern, { 
+          cwd: this.templatePath, 
+          ignore: ['node_modules/**', 'dist/**', 'cli/**', '.git/**'],
+          nodir: false
+        });
+
+        for (const file of files) {
+          const sourcePath = path.join(this.templatePath, file);
+          const destPath = path.join(projectPath, file);
+
+          if (await fs.pathExists(sourcePath)) {
+            const stat = await fs.stat(sourcePath);
+            
+            if (stat.isDirectory()) {
+              // Copy directory
+              await fs.ensureDir(destPath);
+              await fs.copy(sourcePath, destPath);
+            } else {
+              // Copy file
+              await fs.ensureDir(path.dirname(destPath));
+              await fs.copy(sourcePath, destPath);
+            }
+          }
+        }
+      } catch (error: any) {
+        // Log warning but continue with other files
+        console.log(chalk.yellow(`⚠️  Warning: Could not copy pattern '${pattern}': ${error.message}`));
+      }
+    }
+  }
+
+  private async updatePackageJson(projectPath: string, projectName: string): Promise<void> {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.name = projectName;
+      packageJson.description = `API project: ${projectName}`;
+      
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+  }
+
+  private async createGitignore(projectPath: string): Promise<void> {
+    const gitignoreContent = `
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# Firebase
+.firebase/
+firebase-debug.log
+firestore-debug.log
+ui-debug.log
+
+# Temporary folders
+tmp/
+temp/
+`.trim();
+
+    await fs.writeFile(path.join(projectPath, '.gitignore'), gitignoreContent);
+  }
+
+  private async createReadme(projectPath: string, projectName: string): Promise<void> {
+    const readmeContent = `# ${projectName}
+
+A Node.js API project built with TypeScript and Firebase Functions.
+
+## Features
+
+- Express.js server with TypeScript
+- Firebase Functions integration
+- Socket.io for real-time communication
+- MongoDB with Mongoose
+- Authentication system
+- Email notifications
+- Cron jobs
+- Audit logging
+
+## Getting Started
+
+1. Install dependencies:
+   \`\`\`bash
+   npm install
+   \`\`\`
+
+2. Set up environment variables:
+   - Copy \`.env.example\` to \`.env\`
+   - Update the values according to your configuration
+
+3. Start development server:
+   \`\`\`bash
+   npm run serve
+   \`\`\`
+
+## Available Scripts
+
+- \`npm run serve\` - Start development server
+- \`npm run build:dev\` - Build for development
+- \`npm run build:prod\` - Build for production
+- \`npm run deploy\` - Deploy to Firebase
+
+## Project Structure
+
+\`\`\`
+src/
+├── config/          # Configuration files
+├── controllers/     # Route controllers
+├── entities/        # Database entities
+├── helpers/         # Utility functions
+├── routes/          # API routes
+├── schemas/         # Validation schemas
+├── server/          # Server setup
+└── services/        # Business logic
+\`\`\`
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## License
+
+MIT
+`;
+
+    await fs.writeFile(path.join(projectPath, 'README.md'), readmeContent);
+  }
+}