codesummary 1.0.0

package/src/pdfGenerator.js

@@ -0,0 +1,427 @@
+import PDFDocument from 'pdfkit';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ErrorHandler from './errorHandler.js';
+
+/**
+ * PDF Generator for CodeSummary
+ * Creates styled PDF documents with project code content
+ */
+export class PDFGenerator {
+  constructor(config) {
+    this.config = config;
+    this.doc = null;
+    this.pageHeight = 842; // A4 height (595 x 842 points)
+    this.pageWidth = 595;  // A4 width
+  }
+
+  /**
+   * Calculate available content width
+   * @returns {number} Available width for content
+   */
+  getContentWidth() {
+    return this.pageWidth - (this.config.styles.layout.marginLeft + this.config.styles.layout.marginRight);
+  }
+
+  /**
+   * Generate PDF from scanned files
+   * @param {object} filesByExtension - Files grouped by extension
+   * @param {Array} selectedExtensions - Extensions selected by user
+   * @param {string} outputPath - Output file path
+   * @param {string} projectName - Name of the project
+   * @returns {Promise<object>} Object with outputPath and pageCount
+   */
+  async generatePDF(filesByExtension, selectedExtensions, outputPath, projectName) {
+    console.log(chalk.gray('Generating PDF...'));
+
+    // Initialize PDF document with A4 size and optimized margins
+    this.doc = new PDFDocument({
+      size: 'A4',
+      margins: {
+        top: this.config.styles.layout.marginTop,
+        bottom: this.config.styles.layout.marginTop,
+        left: this.config.styles.layout.marginLeft,
+        right: this.config.styles.layout.marginRight
+      }
+    });
+
+
+    // Setup output stream with error handling for files in use
+    let finalOutputPath = outputPath;
+    let outputStream;
+    
+    try {
+      outputStream = fs.createWriteStream(outputPath);
+      this.doc.pipe(outputStream);
+    } catch (error) {
+      if (error.code === 'EBUSY' || error.code === 'EACCES') {
+        // Generate timestamped filename
+        const timestamp = new Date().toISOString()
+          .replace(/[:.]/g, '')
+          .replace('T', '_')
+          .substring(0, 15);
+        
+        const dir = path.dirname(outputPath);
+        const baseName = path.basename(outputPath, '.pdf');
+        finalOutputPath = path.join(dir, `${baseName}_${timestamp}.pdf`);
+        
+        console.log(chalk.yellow(`WARNING: Original file is in use. Creating: ${path.basename(finalOutputPath)}`));
+        outputStream = fs.createWriteStream(finalOutputPath);
+        this.doc.pipe(outputStream);
+      } else {
+        throw error;
+      }
+    }
+
+    // PDFKit handles positioning automatically
+
+    try {
+      // Generate the three main sections
+      await this.generateTitleSection(selectedExtensions, projectName);
+      await this.generateFileStructureSection(filesByExtension, selectedExtensions);
+      await this.generateFileContentSection(filesByExtension, selectedExtensions);
+
+      // No page numbers - content only
+
+      // Finalize document
+      this.doc.end();
+
+      // Wait for file write to complete
+      await new Promise((resolve, reject) => {
+        outputStream.on('finish', resolve);
+        outputStream.on('error', reject);
+      });
+
+      console.log(chalk.green('SUCCESS: PDF generation completed'));
+      return { outputPath: finalOutputPath, pageCount: 'N/A' };
+
+    } catch (error) {
+      ErrorHandler.handlePDFError(error, finalOutputPath || outputPath);
+    }
+  }
+
+  /**
+   * Generate the title/overview section
+   * @param {Array} selectedExtensions - Selected file extensions
+   * @param {string} projectName - Project name
+   */
+  async generateTitleSection(selectedExtensions, projectName) {
+    // Title
+    this.doc
+      .fontSize(20)
+      .fillColor(this.config.styles.colors.title)
+      .font('Helvetica-Bold')
+      .text(this.config.settings.documentTitle, {
+        align: 'center',
+        width: this.getContentWidth()
+      })
+      .moveDown(1);
+    
+    // Subtitle
+    this.doc
+      .fontSize(14)
+      .fillColor(this.config.styles.colors.section)
+      .font('Helvetica')
+      .text(`Project: ${projectName}`, {
+        align: 'center',
+        width: this.getContentWidth()
+      })
+      .moveDown(1);
+    
+    // Generation timestamp
+    const timestamp = new Date().toLocaleString();
+    this.doc
+      .fontSize(10)
+      .fillColor(this.config.styles.colors.footer)
+      .font('Helvetica')
+      .text(`Generated on: ${timestamp}`, {
+        width: this.getContentWidth()
+      })
+      .moveDown(2);
+
+    // Included file types section
+    this.doc
+      .fontSize(16)
+      .fillColor(this.config.styles.colors.section)
+      .font('Helvetica-Bold')
+      .text('Included File Types', {
+        width: this.getContentWidth()
+      })
+      .moveDown(0.5);
+
+    selectedExtensions.forEach(ext => {
+      const description = this.getExtensionDescription(ext);
+      this.doc
+        .fontSize(11)
+        .fillColor(this.config.styles.colors.text)
+        .font('Helvetica')
+        .text(`- ${ext} -> ${description}`, {
+          width: this.getContentWidth()
+        });
+    });
+    
+    this.doc.moveDown(2);
+  }
+
+  /**
+   * Generate the file structure section
+   * @param {object} filesByExtension - Files grouped by extension
+   * @param {Array} selectedExtensions - Selected extensions
+   */
+  async generateFileStructureSection(filesByExtension, selectedExtensions) {
+    // Section header
+    this.doc
+      .fontSize(16)
+      .fillColor(this.config.styles.colors.section)
+      .font('Helvetica-Bold')
+      .text('Project File Structure', {
+        width: this.getContentWidth()
+      })
+      .moveDown(1);
+
+    // Collect all files from selected extensions
+    const allFiles = [];
+    selectedExtensions.forEach(ext => {
+      if (filesByExtension[ext]) {
+        allFiles.push(...filesByExtension[ext]);
+      }
+    });
+
+    // Sort files by path
+    allFiles.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+    // Add file list as continuous text
+    const fileList = allFiles.map(file => file.relativePath).join('\n');
+    
+    this.doc
+      .fontSize(10)
+      .fillColor(this.config.styles.colors.text)
+      .font('Courier')
+      .text(fileList, {
+        width: this.getContentWidth()
+      })
+      .moveDown(2);
+  }
+
+  /**
+   * Generate the file content section
+   * @param {object} filesByExtension - Files grouped by extension
+   * @param {Array} selectedExtensions - Selected extensions
+   */
+  async generateFileContentSection(filesByExtension, selectedExtensions) {
+    // Section header
+    this.doc
+      .fontSize(16)
+      .fillColor(this.config.styles.colors.section)
+      .font('Helvetica-Bold')
+      .text('Project File Content', {
+        width: this.getContentWidth()
+      })
+      .moveDown(2);
+
+    for (const extension of selectedExtensions) {
+      if (!filesByExtension[extension]) continue;
+
+      const files = filesByExtension[extension];
+      
+      for (const file of files) {
+        await this.addFileContent(file);
+      }
+    }
+  }
+
+  /**
+   * Add content of a single file to the PDF
+   * @param {object} file - File object with path and metadata
+   */
+  async addFileContent(file) {
+    // Add file header
+    this.addFileHeader(file.relativePath);
+
+    try {
+      // Read and validate file content
+      const contentBuffer = await fs.readFile(file.absolutePath);
+      
+      // Validate content before processing
+      if (!ErrorHandler.validateFileContent(file.relativePath, contentBuffer)) {
+        this.addErrorContent('File appears to contain binary data');
+        return;
+      }
+      
+      const content = contentBuffer.toString('utf8');
+      
+      // Include all content without truncation
+      const lines = content.split('\n');
+      if (lines.length > 1000) {
+        console.log(chalk.gray(`Processing large file with ${lines.length} lines: ${file.relativePath}`));
+      }
+      
+      await this.addCodeContent(content);
+      
+    } catch (error) {
+      // Handle unreadable files with appropriate error messages
+      let errorMessage = 'Could not read file';
+      
+      if (error.code === 'EACCES') {
+        errorMessage = 'Permission denied';
+      } else if (error.code === 'ENOENT') {
+        errorMessage = 'File not found';
+      } else if (error.code === 'EISDIR') {
+        errorMessage = 'Path is a directory';
+      } else if (error.message) {
+        errorMessage = error.message;
+      }
+      
+      this.addErrorContent(errorMessage);
+    }
+  }
+
+  /**
+   * Add file header
+   * @param {string} filePath - Relative file path
+   */
+  addFileHeader(filePath) {
+    this.doc
+      .moveDown(1)
+      .fontSize(12)
+      .fillColor(this.config.styles.colors.section)
+      .font('Helvetica-Bold')
+      .text(`File: ${filePath}`, {
+        width: this.getContentWidth()
+      })
+      .moveDown(0.5);
+  }
+
+  /**
+   * Add code content with proper formatting
+   * @param {string} content - File content
+   */
+  async addCodeContent(content) {
+    // Clean and prepare content
+    const cleanContent = this.prepareContent(content);
+    
+    this.doc
+      .fontSize(9)
+      .fillColor(this.config.styles.colors.text)
+      .font('Courier')
+      .text(cleanContent, {
+        width: this.getContentWidth(),
+        align: 'left'
+      });
+    
+    // Add some spacing after code block
+    this.doc.moveDown(1);
+  }
+
+  /**
+   * Add error content for unreadable files
+   * @param {string} errorMessage - Error message to display
+   */
+  addErrorContent(errorMessage) {
+    this.doc
+      .fontSize(10)
+      .fillColor(this.config.styles.colors.error)
+      .font('Helvetica-Oblique')
+      .text(`ERROR: ${errorMessage}`, {
+        width: this.getContentWidth()
+      })
+      .moveDown(0.5);
+  }
+
+  /**
+   * Prepare content for PDF rendering
+   * @param {string} content - Raw file content
+   * @returns {string} Cleaned content
+   */
+  prepareContent(content) {
+    return content
+      .replace(/\r\n/g, '\n')  // Normalize line endings
+      .replace(/\r/g, '\n')    // Handle old Mac line endings
+      .replace(/\t/g, '    ')  // Replace tabs with 4 spaces for better alignment
+      .replace(/[^\x20-\x7E\n\u00A0-\uFFFF]/g, ''); // Remove control chars, keep Unicode text
+  }
+
+  // All text methods removed - using direct PDFKit calls for simplicity
+
+  // Page numbering removed to prevent duplicate pages
+
+  /**
+   * Get description for file extension
+   * @param {string} extension - File extension
+   * @returns {string} Description
+   */
+  getExtensionDescription(extension) {
+    const descriptions = {
+      '.js': 'JavaScript',
+      '.ts': 'TypeScript',
+      '.jsx': 'React JSX',
+      '.tsx': 'TypeScript JSX',
+      '.json': 'JSON',
+      '.xml': 'XML',
+      '.html': 'HTML',
+      '.css': 'CSS',
+      '.scss': 'SCSS',
+      '.md': 'Markdown',
+      '.txt': 'Text',
+      '.py': 'Python',
+      '.java': 'Java',
+      '.cs': 'C#',
+      '.cpp': 'C++',
+      '.c': 'C',
+      '.h': 'Header',
+      '.yaml': 'YAML',
+      '.yml': 'YAML',
+      '.sh': 'Shell Script',
+      '.bat': 'Batch File'
+    };
+
+    return descriptions[extension] || 'Unknown';
+  }
+
+  /**
+   * Generate output file path with timestamp fallback if file is in use
+   * @param {string} projectName - Project name
+   * @param {string} outputDir - Output directory
+   * @returns {string} Complete output file path
+   */
+  static generateOutputPath(projectName, outputDir) {
+    const baseFileName = `${projectName.toUpperCase()}_code.pdf`;
+    const basePath = path.join(outputDir, baseFileName);
+    
+    // Check if file exists and is potentially in use
+    if (fs.existsSync(basePath)) {
+      try {
+        // Try to open the file to check if it's in use
+        const fd = fs.openSync(basePath, 'r+');
+        fs.closeSync(fd);
+        // File is not in use, can overwrite
+        return basePath;
+      } catch (error) {
+        // File is in use, generate timestamped name
+        if (error.code === 'EBUSY' || error.code === 'EACCES') {
+          const timestamp = new Date().toISOString()
+            .replace(/[:.]/g, '')
+            .replace('T', '_')
+            .substring(0, 15); // YYYYMMDD_HHMMSS
+          
+          const timestampedFileName = `${projectName.toUpperCase()}_code_${timestamp}.pdf`;
+          console.log(chalk.yellow(`WARNING: Original file is in use. Creating: ${timestampedFileName}`));
+          return path.join(outputDir, timestampedFileName);
+        }
+      }
+    }
+    
+    return basePath;
+  }
+
+  /**
+   * Ensure output directory exists
+   * @param {string} outputDir - Output directory path
+   */
+  static async ensureOutputDirectory(outputDir) {
+    await fs.ensureDir(outputDir);
+  }
+}
+
+export default PDFGenerator;