servcraft 0.1.0 → 0.1.1

package/src/cli/utils/field-parser.ts

@@ -146,8 +146,20 @@ export function parseField(fieldStr: string): FieldDefinition {
 
   // Validate type
   const validTypes: FieldType[] = [
-    'string', 'number', 'boolean', 'date', 'datetime',
-    'text', 'json', 'email', 'url', 'uuid', 'int', 'float', 'decimal', 'enum'
+    'string',
+    'number',
+    'boolean',
+    'date',
+    'datetime',
+    'text',
+    'json',
+    'email',
+    'url',
+    'uuid',
+    'int',
+    'float',
+    'decimal',
+    'enum',
   ];
 
   let type: FieldType = 'string';
@@ -192,10 +204,7 @@ export function parseField(fieldStr: string): FieldDefinition {
 export function parseFields(fieldsStr: string): FieldDefinition[] {
   if (!fieldsStr) return [];
 
-  return fieldsStr
-    .split(/\s+/)
-    .filter(Boolean)
-    .map(parseField);
+  return fieldsStr.split(/\s+/).filter(Boolean).map(parseField);
 }
 
 /**
@@ -303,7 +312,7 @@ export function generatePrismaModel(
   lines.push('');
 
   // Add indexes for unique fields
-  const uniqueFields = fields.filter(f => f.isUnique);
+  const uniqueFields = fields.filter((f) => f.isUnique);
   for (const field of uniqueFields) {
     lines.push(`  @@index([${field.name}])`);
   }

package/src/cli/utils/interactive-prompt.ts

@@ -0,0 +1,223 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export interface MergeChoice {
+  action: 'skip' | 'update' | 'overwrite' | 'diff' | 'backup-overwrite';
+}
+
+export interface FileChoice {
+  action: 'merge' | 'keep' | 'overwrite' | 'diff' | 'skip';
+}
+
+/**
+ * Interactive prompt utilities
+ */
+export class InteractivePrompt {
+  /**
+   * Ask what to do when module already exists
+   */
+  static async askModuleExists(
+    moduleName: string,
+    hasModifications: boolean
+  ): Promise<MergeChoice> {
+    console.log(chalk.yellow(`\n⚠️  Module "${moduleName}" already exists`));
+
+    if (hasModifications) {
+      console.log(chalk.yellow('   Some files have been modified by you.\n'));
+    }
+
+    const { action } = await inquirer.prompt<{ action: MergeChoice['action'] }>([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          {
+            name: '✓ Skip (keep existing files, recommended if you made custom changes)',
+            value: 'skip',
+          },
+          {
+            name: '↻ Update (merge new features, preserve your customizations)',
+            value: 'update',
+          },
+          {
+            name: '⚠  Overwrite (replace all files, will lose your changes)',
+            value: 'overwrite',
+          },
+          {
+            name: '📋 Show diff (see what changed)',
+            value: 'diff',
+          },
+          {
+            name: '💾 Backup & overwrite (save backup then replace)',
+            value: 'backup-overwrite',
+          },
+        ],
+        default: 'skip',
+      },
+    ]);
+
+    return { action };
+  }
+
+  /**
+   * Ask what to do with a specific file
+   */
+  static async askFileAction(
+    fileName: string,
+    isModified: boolean,
+    yourLines: number,
+    newLines: number
+  ): Promise<FileChoice> {
+    console.log(chalk.cyan(`\n📁 ${fileName}`));
+    console.log(
+      chalk.gray(`   Your version: ${yourLines} lines${isModified ? ' (modified)' : ''}`)
+    );
+    console.log(chalk.gray(`   New version: ${newLines} lines\n`));
+
+    const { action } = await inquirer.prompt<{ action: FileChoice['action'] }>([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Action for this file:',
+        choices: [
+          {
+            name: '[M]erge - Smart merge, preserve your changes',
+            value: 'merge',
+          },
+          {
+            name: '[K]eep - Keep your version (skip update)',
+            value: 'keep',
+          },
+          {
+            name: '[O]verwrite - Use new version',
+            value: 'overwrite',
+          },
+          {
+            name: '[D]iff - Show differences',
+            value: 'diff',
+          },
+          {
+            name: '[S]kip - Skip this file',
+            value: 'skip',
+          },
+        ],
+        default: isModified ? 'merge' : 'overwrite',
+      },
+    ]);
+
+    return { action };
+  }
+
+  /**
+   * Confirm action
+   */
+  static async confirm(message: string, defaultValue = false): Promise<boolean> {
+    const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message,
+        default: defaultValue,
+      },
+    ]);
+
+    return confirmed;
+  }
+
+  /**
+   * Display diff and ask to continue
+   */
+  static async showDiffAndAsk(diff: string): Promise<boolean> {
+    console.log(chalk.cyan('\n📊 Differences:\n'));
+    console.log(diff);
+
+    return await this.confirm('\nDo you want to proceed with this change?', true);
+  }
+
+  /**
+   * Display merge conflicts
+   */
+  static displayConflicts(conflicts: string[]): void {
+    console.log(chalk.red('\n⚠️  Merge Conflicts Detected:\n'));
+    conflicts.forEach((conflict, i) => {
+      console.log(chalk.yellow(`   ${i + 1}. ${conflict}`));
+    });
+    console.log(chalk.gray('\n   Conflict markers have been added to the file:'));
+    console.log(chalk.gray('   <<<<<<< YOUR VERSION'));
+    console.log(chalk.gray('   ... your code ...'));
+    console.log(chalk.gray('   ======='));
+    console.log(chalk.gray('   ... new code ...'));
+    console.log(chalk.gray('   >>>>>>> NEW VERSION\n'));
+  }
+
+  /**
+   * Show backup location
+   */
+  static showBackupCreated(backupPath: string): void {
+    console.log(chalk.green(`\n✓ Backup created: ${chalk.cyan(backupPath)}`));
+  }
+
+  /**
+   * Show merge summary
+   */
+  static showMergeSummary(stats: {
+    merged: number;
+    kept: number;
+    overwritten: number;
+    conflicts: number;
+  }): void {
+    console.log(chalk.bold('\n📊 Merge Summary:\n'));
+    if (stats.merged > 0) {
+      console.log(chalk.green(`   ✓ Merged: ${stats.merged} file(s)`));
+    }
+    if (stats.kept > 0) {
+      console.log(chalk.blue(`   → Kept: ${stats.kept} file(s)`));
+    }
+    if (stats.overwritten > 0) {
+      console.log(chalk.yellow(`   ⚠ Overwritten: ${stats.overwritten} file(s)`));
+    }
+    if (stats.conflicts > 0) {
+      console.log(chalk.red(`   ⚠ Conflicts: ${stats.conflicts} file(s)`));
+      console.log(chalk.gray('\n   Please resolve conflicts manually before committing.\n'));
+    }
+  }
+
+  /**
+   * Ask for batch action on all files
+   */
+  static async askBatchAction(): Promise<
+    'individual' | 'merge-all' | 'keep-all' | 'overwrite-all'
+  > {
+    const { action } = await inquirer.prompt<{
+      action: 'individual' | 'merge-all' | 'keep-all' | 'overwrite-all';
+    }>([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Multiple files found. Choose action:',
+        choices: [
+          {
+            name: 'Ask for each file individually (recommended)',
+            value: 'individual',
+          },
+          {
+            name: 'Merge all files automatically',
+            value: 'merge-all',
+          },
+          {
+            name: 'Keep all existing files (skip update)',
+            value: 'keep-all',
+          },
+          {
+            name: 'Overwrite all files with new versions',
+            value: 'overwrite-all',
+          },
+        ],
+        default: 'individual',
+      },
+    ]);
+
+    return action;
+  }
+}

package/src/cli/utils/template-manager.ts

@@ -0,0 +1,346 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import { existsSync } from 'fs';
+
+export interface Template {
+  /** Template name */
+  name: string;
+  /** Template content */
+  content: string;
+  /** Template hash for change detection */
+  hash: string;
+  /** Template version */
+  version: string;
+}
+
+export interface ModuleManifest {
+  /** Module name */
+  name: string;
+  /** Module version */
+  version: string;
+  /** Files in this module */
+  files: Record<string, { hash: string; path: string }>;
+  /** Install date */
+  installedAt: Date;
+  /** Last update */
+  updatedAt: Date;
+}
+
+/**
+ * Template Manager
+ * Manages module templates and tracks installed versions
+ */
+export class TemplateManager {
+  private templatesDir: string;
+  private manifestsDir: string;
+
+  constructor(projectRoot: string) {
+    this.templatesDir = path.join(projectRoot, '.servcraft', 'templates');
+    this.manifestsDir = path.join(projectRoot, '.servcraft', 'manifests');
+  }
+
+  /**
+   * Initialize template system
+   */
+  async initialize(): Promise<void> {
+    await fs.mkdir(this.templatesDir, { recursive: true });
+    await fs.mkdir(this.manifestsDir, { recursive: true });
+  }
+
+  /**
+   * Save module template
+   */
+  async saveTemplate(moduleName: string, files: Record<string, string>): Promise<void> {
+    await this.initialize();
+
+    const moduleTemplateDir = path.join(this.templatesDir, moduleName);
+    await fs.mkdir(moduleTemplateDir, { recursive: true });
+
+    // Save each file
+    for (const [fileName, content] of Object.entries(files)) {
+      const filePath = path.join(moduleTemplateDir, fileName);
+      await fs.writeFile(filePath, content, 'utf-8');
+    }
+  }
+
+  /**
+   * Get template content
+   */
+  async getTemplate(moduleName: string, fileName: string): Promise<string | null> {
+    try {
+      const filePath = path.join(this.templatesDir, moduleName, fileName);
+      return await fs.readFile(filePath, 'utf-8');
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save module manifest
+   */
+  async saveManifest(moduleName: string, files: Record<string, string>): Promise<void> {
+    await this.initialize();
+
+    const fileHashes: Record<string, { hash: string; path: string }> = {};
+
+    for (const [fileName, content] of Object.entries(files)) {
+      fileHashes[fileName] = {
+        hash: this.hashContent(content),
+        path: `src/modules/${moduleName}/${fileName}`,
+      };
+    }
+
+    const manifest: ModuleManifest = {
+      name: moduleName,
+      version: '1.0.0',
+      files: fileHashes,
+      installedAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    const manifestPath = path.join(this.manifestsDir, `${moduleName}.json`);
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  }
+
+  /**
+   * Get module manifest
+   */
+  async getManifest(moduleName: string): Promise<ModuleManifest | null> {
+    try {
+      const manifestPath = path.join(this.manifestsDir, `${moduleName}.json`);
+      const content = await fs.readFile(manifestPath, 'utf-8');
+      return JSON.parse(content) as ModuleManifest;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if file has been modified by user
+   */
+  async isFileModified(
+    moduleName: string,
+    fileName: string,
+    currentContent: string
+  ): Promise<boolean> {
+    const manifest = await this.getManifest(moduleName);
+
+    if (!manifest || !manifest.files[fileName]) {
+      return false;
+    }
+
+    const originalHash = manifest.files[fileName].hash;
+    const currentHash = this.hashContent(currentContent);
+
+    return originalHash !== currentHash;
+  }
+
+  /**
+   * Get all modified files in a module
+   */
+  async getModifiedFiles(
+    moduleName: string,
+    moduleDir: string
+  ): Promise<
+    Array<{ fileName: string; isModified: boolean; originalHash: string; currentHash: string }>
+  > {
+    const manifest = await this.getManifest(moduleName);
+
+    if (!manifest) {
+      return [];
+    }
+
+    const results = [];
+
+    for (const [fileName, fileInfo] of Object.entries(manifest.files)) {
+      const filePath = path.join(moduleDir, fileName);
+
+      if (!existsSync(filePath)) {
+        results.push({
+          fileName,
+          isModified: true,
+          originalHash: fileInfo.hash,
+          currentHash: '',
+        });
+        continue;
+      }
+
+      const currentContent = await fs.readFile(filePath, 'utf-8');
+      const currentHash = this.hashContent(currentContent);
+
+      results.push({
+        fileName,
+        isModified: fileInfo.hash !== currentHash,
+        originalHash: fileInfo.hash,
+        currentHash,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Create backup of module
+   */
+  async createBackup(moduleName: string, moduleDir: string): Promise<string> {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+    const backupDir = path.join(path.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
+
+    await this.copyDirectory(moduleDir, backupDir);
+
+    return backupDir;
+  }
+
+  /**
+   * Copy directory recursively
+   */
+  private async copyDirectory(src: string, dest: string): Promise<void> {
+    await fs.mkdir(dest, { recursive: true });
+
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Perform 3-way merge
+   */
+  async mergeFiles(
+    original: string,
+    modified: string,
+    incoming: string
+  ): Promise<{ merged: string; hasConflicts: boolean; conflicts: string[] }> {
+    const conflicts: string[] = [];
+    let hasConflicts = false;
+
+    // Simple line-based merge
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+    const incomingLines = incoming.split('\n');
+
+    const merged: string[] = [];
+
+    // This is a simplified merge - in production, use a proper diff3 algorithm
+    // For now, we'll use a basic strategy:
+    // 1. If modified === original, use incoming (user hasn't changed it)
+    // 2. If modified !== original, keep modified (user changed it)
+    // 3. If both changed, mark as conflict
+
+    const maxLength = Math.max(originalLines.length, modifiedLines.length, incomingLines.length);
+
+    for (let i = 0; i < maxLength; i++) {
+      const origLine = originalLines[i] || '';
+      const modLine = modifiedLines[i] || '';
+      const incLine = incomingLines[i] || '';
+
+      if (modLine === origLine) {
+        // User hasn't modified, use incoming
+        merged.push(incLine);
+      } else if (incLine === origLine) {
+        // Template hasn't changed, keep user's modification
+        merged.push(modLine);
+      } else if (modLine === incLine) {
+        // Both have same change, no conflict
+        merged.push(modLine);
+      } else {
+        // Conflict: both modified differently
+        hasConflicts = true;
+        conflicts.push(`Line ${i + 1}: User and template both modified`);
+        merged.push(`<<<<<<< YOUR VERSION`);
+        merged.push(modLine);
+        merged.push(`=======`);
+        merged.push(incLine);
+        merged.push(`>>>>>>> NEW VERSION`);
+      }
+    }
+
+    return {
+      merged: merged.join('\n'),
+      hasConflicts,
+      conflicts,
+    };
+  }
+
+  /**
+   * Generate diff between two files
+   */
+  generateDiff(original: string, modified: string): string {
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+
+    const diff: string[] = [];
+    diff.push('--- Original');
+    diff.push('+++ Modified');
+    diff.push('');
+
+    const maxLength = Math.max(originalLines.length, modifiedLines.length);
+
+    for (let i = 0; i < maxLength; i++) {
+      const origLine = originalLines[i];
+      const modLine = modifiedLines[i];
+
+      if (origLine !== modLine) {
+        if (origLine !== undefined) {
+          diff.push(`- ${origLine}`);
+        }
+        if (modLine !== undefined) {
+          diff.push(`+ ${modLine}`);
+        }
+      }
+    }
+
+    return diff.join('\n');
+  }
+
+  /**
+   * Hash content for change detection
+   */
+  private hashContent(content: string): string {
+    return createHash('md5').update(content).digest('hex');
+  }
+
+  /**
+   * Check if module is installed
+   */
+  async isModuleInstalled(moduleName: string): Promise<boolean> {
+    const manifest = await this.getManifest(moduleName);
+    return manifest !== null;
+  }
+
+  /**
+   * Update manifest after merge
+   */
+  async updateManifest(moduleName: string, files: Record<string, string>): Promise<void> {
+    const manifest = await this.getManifest(moduleName);
+
+    if (!manifest) {
+      await this.saveManifest(moduleName, files);
+      return;
+    }
+
+    const fileHashes: Record<string, { hash: string; path: string }> = {};
+
+    for (const [fileName, content] of Object.entries(files)) {
+      fileHashes[fileName] = {
+        hash: this.hashContent(content),
+        path: `src/modules/${moduleName}/${fileName}`,
+      };
+    }
+
+    manifest.files = fileHashes;
+    manifest.updatedAt = new Date();
+
+    const manifestPath = path.join(this.manifestsDir, `${moduleName}.json`);
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  }
+}