vg-coder-cli 1.0.5 → 1.0.7

package/.vgignore

@@ -0,0 +1,10 @@
+# VG Coder specific ignores
+*.tgz
+coverage/
+vg-output/
+test-small/
+
+# Additional ignores for VG Coder
+*.map
+*.min.js
+*.min.css

package/README.md

@@ -6,6 +6,7 @@
 
 - 🔍 **Phát hiện loại dự án**: Tự động nhận diện Angular, Spring Boot, React, Vue, Node.js, Python, Java, .NET
 - 📁 **Xử lý .gitignore**: Tuân thủ chuẩn Git với multi-level ignore rules
+-  **.vgignore support**: Priority cao hơn .gitignore, với syntax giống hệt
 - 📄 **Scan và nối file**: Quét toàn bộ dự án và nối file mã nguồn
 - 🧮 **Đếm token**: Sử dụng tiktoken để đếm token chính xác cho AI models
 - ✂️ **Chia nhỏ nội dung**: Smart chunking với preserve structure

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "🚀 CLI tool to analyze projects, concatenate source files, count tokens, and export HTML with syntax highlighting and copy functionality",
   "main": "src/index.js",
   "bin": {

package/src/exporter/html-exporter.js

@@ -39,11 +39,15 @@ class HtmlExporter {
     
     // Tạo combined view
     await this.createCombinedPage(chunks, metadata);
-    
+
+    // Tạo combined.txt cho AI tools
+    await this.createCombinedTxtFile(chunks, metadata);
+
     return {
       indexPath: path.join(this.outputPath, 'index.html'),
       chunksPath: path.join(this.outputPath, 'chunks'),
       combinedPath: path.join(this.outputPath, 'combined.html'),
+      combinedTxtPath: path.join(this.outputPath, 'combined.txt'),
       totalFiles: chunks.length
     };
   }
@@ -250,6 +254,126 @@ Nếu file chưa tồn tại, script sẽ tự tạo file và thư mục cha.</c
     await fs.writeFile(path.join(this.outputPath, 'combined.html'), html);
   }
 
+  /**
+   * Tạo combined.txt file cho AI tools với formatting tối ưu
+   */
+  async createCombinedTxtFile(chunks, metadata) {
+    // Sử dụng files gốc nếu có, nếu không thì dùng chunks
+    const files = metadata.files;
+
+    if (files && files.length > 0) {
+      // Tạo content từ files gốc với formatting AI-friendly
+      let content = '';
+
+      // Minimal header cho AI context
+      content += `// VG Coder Analysis - ${metadata.projectInfo?.primary || 'Unknown'} Project\n`;
+      content += `// Files: ${files.length} | Generated: ${new Date().toISOString()}\n\n`;
+
+      // Nội dung từng file với boundaries rõ ràng
+      for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+
+        // File boundary marker
+        content += `// ===== FILE: ${file.relativePath} =====\n`;
+
+        // Nội dung file nguyên bản
+        content += file.content;
+
+        // Đảm bảo file kết thúc bằng newline
+        if (!file.content.endsWith('\n')) {
+          content += '\n';
+        }
+
+        // Separator giữa các files
+        if (i < files.length - 1) {
+          content += '\n';
+        }
+      }
+
+      await fs.writeFile(path.join(this.outputPath, 'combined.txt'), content, 'utf8');
+    } else {
+      // Fallback: sử dụng chunks (legacy)
+      let content = '';
+
+      // Minimal header cho AI context
+      content += `// VG Coder Analysis - ${metadata.projectInfo?.primary || 'Unknown'} Project\n`;
+      content += `// Files: ${chunks.length} | Generated: ${new Date().toISOString()}\n\n`;
+
+      // Parse chunks để extract file content với boundaries rõ ràng
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+
+        // Extract file content từ chunk, bỏ qua headers và separators
+        const cleanContent = this.extractCleanContent(chunk.content);
+
+        if (cleanContent.trim()) {
+          content += cleanContent;
+
+          // Đảm bảo kết thúc bằng newline
+          if (!cleanContent.endsWith('\n')) {
+            content += '\n';
+          }
+
+          // Separator giữa các chunks (minimal)
+          if (i < chunks.length - 1) {
+            content += '\n';
+          }
+        }
+      }
+
+      await fs.writeFile(path.join(this.outputPath, 'combined.txt'), content, 'utf8');
+    }
+  }
+
+  /**
+   * Extract clean content từ chunk, loại bỏ headers và formatting
+   */
+  extractCleanContent(chunkContent) {
+    const lines = chunkContent.split('\n');
+    let cleanLines = [];
+    let inFileContent = false;
+    let currentFilePath = '';
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Detect file header
+      if (line.includes('================================================================================')) {
+        if (i + 1 < lines.length && lines[i + 1].startsWith('File: ')) {
+          // Start of new file
+          currentFilePath = lines[i + 1].replace('File: ', '').trim();
+          cleanLines.push(`// ===== FILE: ${currentFilePath} =====`);
+          inFileContent = false;
+          i += 2; // Skip header lines
+          continue;
+        }
+      }
+
+      // Skip project headers and structure
+      if (line.startsWith('# Project Analysis Report') ||
+          line.startsWith('Generated:') ||
+          line.startsWith('Project Path:') ||
+          line.startsWith('## Statistics') ||
+          line.startsWith('## Project Structure') ||
+          line.startsWith('- Total') ||
+          line.startsWith('- Extensions:') ||
+          line.startsWith('```') ||
+          line.startsWith('├──') ||
+          line.startsWith('└──') ||
+          line.trim() === '') {
+        continue;
+      }
+
+      // Add actual file content
+      if (currentFilePath && !line.includes('================================================================================')) {
+        cleanLines.push(line);
+        inFileContent = true;
+      }
+    }
+
+    return cleanLines.join('\n');
+  }
+
   /**
    * Copy static assets
    */

package/src/ignore/ignore-manager.js

@@ -19,6 +19,8 @@ class IgnoreManager {
     return [
       // Node.js
       'node_modules/',
+      'package-lock.json',
+      'yarn.lock',
       'npm-debug.log*',
       'yarn-debug.log*',
       'yarn-error.log*',
@@ -126,17 +128,17 @@ class IgnoreManager {
     // Thêm default ignores
     ig.add(this.defaultIgnores);
     
-    // Đọc .gitignore từ root đến thư mục hiện tại
+    // Đọc .gitignore và .vgignore từ root đến thư mục hiện tại
     const pathParts = relativePath ? relativePath.split(path.sep) : [];
     let currentPath = this.projectPath;
-    
-    // Đọc .gitignore từ root
-    await this.addGitignoreFromPath(ig, currentPath);
-    
-    // Đọc .gitignore từ các thư mục con theo thứ tự
+
+    // Đọc .gitignore và .vgignore từ root
+    await this.addIgnoreFromPath(ig, currentPath);
+
+    // Đọc .gitignore và .vgignore từ các thư mục con theo thứ tự
     for (const part of pathParts) {
       currentPath = path.join(currentPath, part);
-      await this.addGitignoreFromPath(ig, currentPath);
+      await this.addIgnoreFromPath(ig, currentPath);
     }
     
     this.ignoreInstances.set(cacheKey, ig);
@@ -144,26 +146,38 @@ class IgnoreManager {
   }
 
   /**
-   * Thêm patterns từ .gitignore file
+   * Thêm patterns từ .gitignore và .vgignore files
    */
-  async addGitignoreFromPath(ig, dirPath) {
+  async addIgnoreFromPath(ig, dirPath) {
+    // Đọc .gitignore
     const gitignorePath = path.join(dirPath, '.gitignore');
-    
     try {
       if (await fs.pathExists(gitignorePath)) {
         const content = await fs.readFile(gitignorePath, 'utf8');
-        const patterns = this.parseGitignoreContent(content, dirPath);
+        const patterns = this.parseIgnoreContent(content, dirPath);
         ig.add(patterns);
       }
     } catch (error) {
       // Ignore errors reading .gitignore files
     }
+
+    // Đọc .vgignore (có priority cao hơn .gitignore)
+    const vgignorePath = path.join(dirPath, '.vgignore');
+    try {
+      if (await fs.pathExists(vgignorePath)) {
+        const content = await fs.readFile(vgignorePath, 'utf8');
+        const patterns = this.parseIgnoreContent(content, dirPath);
+        ig.add(patterns);
+      }
+    } catch (error) {
+      // Ignore errors reading .vgignore files
+    }
   }
 
   /**
-   * Parse nội dung .gitignore
+   * Parse nội dung .gitignore và .vgignore
    */
-  parseGitignoreContent(content, basePath) {
+  parseIgnoreContent(content, basePath) {
     const lines = content.split('\n');
     const patterns = [];
     

package/src/index.js

@@ -9,6 +9,7 @@ const ProjectDetector = require('./detectors/project-detector');
 const FileScanner = require('./scanner/file-scanner');
 const TokenManager = require('./tokenizer/token-manager');
 const HtmlExporter = require('./exporter/html-exporter');
+const ClipboardManager = require('./utils/clipboard');
 
 /**
  * Main CLI Application
@@ -39,6 +40,8 @@ class VGCoderCLI {
       .option('--include-hidden', 'Bao gồm file ẩn')
       .option('--no-structure', 'Không ưu tiên giữ cấu trúc file')
       .option('--theme <theme>', 'Theme cho syntax highlighting', 'github')
+      .option('--clipboard-only', 'Copy content to clipboard without creating files')
+      .option('--clipboard', 'Alias for --clipboard-only')
       .action(this.handleAnalyze.bind(this));
 
     // Info command
@@ -60,17 +63,25 @@ class VGCoderCLI {
    */
   async handleAnalyze(projectPath, options) {
     const spinner = ora('Initializing analysis...').start();
-    
+
     try {
       // Resolve project path
       projectPath = path.resolve(projectPath || process.cwd());
-      const outputPath = path.resolve(options.output);
+
+      // Check if clipboard-only mode
+      const clipboardMode = options.clipboardOnly || options.clipboard;
+      const outputPath = clipboardMode ? null : path.resolve(options.output || './vg-output');
       
       // Validate project path
       if (!await fs.pathExists(projectPath)) {
         throw new Error(`Project path does not exist: ${projectPath}`);
       }
 
+      // Validate output path for non-clipboard mode
+      if (!clipboardMode && !outputPath) {
+        throw new Error('Output path is required for non-clipboard mode');
+      }
+
       spinner.text = 'Detecting project type...';
       
       // Detect project type
@@ -123,10 +134,42 @@ class VGCoderCLI {
       console.log(`Estimated Chunks: ${tokenAnalysis.summary.estimatedChunks}`);
 
       spinner.text = 'Creating content chunks...';
-      
-      // Create combined content
+
+      if (clipboardMode) {
+        // Clipboard mode: create AI-friendly content and copy to clipboard
+        spinner.text = 'Creating AI-friendly content...';
+
+        const aiContent = await scanner.createCombinedContentForAI(scanResult.files, {
+          includeStats: false,
+          includeTree: false,
+          preserveLineNumbers: true
+        });
+
+        spinner.text = 'Copying to clipboard...';
+
+        await ClipboardManager.copyToClipboard(aiContent);
+        const contentInfo = ClipboardManager.getContentInfo(aiContent);
+
+        // Cleanup
+        tokenManager.cleanup();
+
+        spinner.succeed('Content copied to clipboard successfully!');
+
+        console.log(chalk.green('\n📋 Clipboard Content:'));
+        console.log(`Files: ${chalk.cyan(scanResult.files.length)}`);
+        console.log(`Lines: ${chalk.cyan(contentInfo.lines.toLocaleString())}`);
+        console.log(`Characters: ${chalk.cyan(contentInfo.characters.toLocaleString())}`);
+        console.log(`Size: ${chalk.cyan(contentInfo.size)}`);
+
+        console.log(chalk.blue('\n💡 Ready for AI analysis!'));
+        console.log('Content is now in your clipboard and ready to paste into AI tools.');
+
+        return; // Exit early for clipboard mode
+      }
+
+      // Normal mode: create HTML output
       const combinedContent = await scanner.createCombinedContent(scanResult.files);
-      
+
       // Chunk content
       const chunks = await tokenManager.chunkContent(combinedContent, {
         projectType: projectInfo.primary,
@@ -153,7 +196,8 @@ class VGCoderCLI {
         projectInfo: projectInfo,
         scanStats: scanResult.stats,
         tokenStats: tokenAnalysis.summary,
-        directoryStructure: treeStructure
+        directoryStructure: treeStructure,
+        files: scanResult.files // Thêm files gốc để tạo combined.txt
       });
       
       // Cleanup
@@ -164,6 +208,9 @@ class VGCoderCLI {
       console.log(chalk.green('\n✅ Output Generated:'));
       console.log(`Index: ${chalk.cyan(exportResult.indexPath)}`);
       console.log(`Combined: ${chalk.cyan(exportResult.combinedPath)}`);
+      if (exportResult.combinedTxtPath) {
+        console.log(`Combined.txt: ${chalk.cyan(exportResult.combinedTxtPath)}`);
+      }
       console.log(`Chunks: ${chalk.cyan(exportResult.chunksPath)}`);
       console.log(`Total Files: ${exportResult.totalFiles}`);
       

package/src/scanner/file-scanner.js

@@ -446,6 +446,54 @@ Size: {size} bytes | Lines: {lines}
     return '\n\n';
   }
 
+  /**
+   * Tạo nội dung kết hợp cho AI tools với formatting chính xác
+   */
+  async createCombinedContentForAI(files, options = {}) {
+    const {
+      includeStats = false,
+      includeTree = false,
+      preserveLineNumbers = true
+    } = options;
+
+    let content = '';
+
+    // Header với thông tin project (tùy chọn)
+    if (includeStats) {
+      content += this.generateProjectHeader(files);
+      content += '\n\n';
+    }
+
+    // Cấu trúc thư mục (tùy chọn)
+    if (includeTree) {
+      content += this.generateTreeStructure(files);
+      content += '\n\n';
+    }
+
+    // Nội dung từng file với formatting chính xác
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+
+      // File boundary marker - không ảnh hưởng line numbering
+      content += `// ===== FILE: ${file.relativePath} =====\n`;
+
+      // Nội dung file nguyên bản
+      content += file.content;
+
+      // Đảm bảo file kết thúc bằng newline
+      if (!file.content.endsWith('\n')) {
+        content += '\n';
+      }
+
+      // Separator giữa các files
+      if (i < files.length - 1) {
+        content += '\n';
+      }
+    }
+
+    return content;
+  }
+
   /**
    * Tạo header thông tin project
    */

package/src/tokenizer/token-manager.js

@@ -247,17 +247,15 @@ class TokenManager {
     let currentTokens = 0;
     let chunkIndex = 0;
     
-    // Thêm header cho file
-    const header = `\n=== Large File: ${filePath} (Part {part}) ===\n`;
-    
+    // Không thêm header "Large File" nữa để UI sạch hơn
+
     for (const line of lines) {
       const lineTokens = this.countTokens(line + '\n');
-      
-      if (currentTokens + lineTokens > this.options.maxTokens - 100 && currentChunk) { // Reserve 100 tokens for header
-        const partHeader = header.replace('{part}', (chunkIndex + 1).toString());
+
+      if (currentTokens + lineTokens > this.options.maxTokens && currentChunk) {
         chunks.push({
-          content: partHeader + currentChunk.trim(),
-          tokens: this.countTokens(partHeader + currentChunk.trim()),
+          content: currentChunk.trim(),
+          tokens: this.countTokens(currentChunk.trim()),
           chunkIndex: chunkIndex++,
           totalChunks: 0,
           metadata: { 
@@ -277,10 +275,9 @@ class TokenManager {
     
     // Thêm chunk cuối cùng
     if (currentChunk.trim()) {
-      const partHeader = header.replace('{part}', (chunkIndex + 1).toString());
       chunks.push({
-        content: partHeader + currentChunk.trim(),
-        tokens: this.countTokens(partHeader + currentChunk.trim()),
+        content: currentChunk.trim(),
+        tokens: this.countTokens(currentChunk.trim()),
         chunkIndex: chunkIndex++,
         totalChunks: 0,
         metadata: { 

package/src/utils/clipboard.js

@@ -0,0 +1,170 @@
+const { spawn } = require('child_process');
+const os = require('os');
+
+/**
+ * Cross-platform clipboard utility
+ */
+class ClipboardManager {
+  /**
+   * Copy text to clipboard
+   */
+  static async copyToClipboard(text) {
+    const platform = os.platform();
+    
+    try {
+      switch (platform) {
+        case 'darwin': // macOS
+          return await this.copyMacOS(text);
+        case 'win32': // Windows
+          return await this.copyWindows(text);
+        case 'linux': // Linux
+          return await this.copyLinux(text);
+        default:
+          throw new Error(`Unsupported platform: ${platform}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to copy to clipboard: ${error.message}`);
+    }
+  }
+
+  /**
+   * Copy to clipboard on macOS
+   */
+  static async copyMacOS(text) {
+    return new Promise((resolve, reject) => {
+      const pbcopy = spawn('pbcopy');
+      
+      pbcopy.stdin.write(text);
+      pbcopy.stdin.end();
+      
+      pbcopy.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`pbcopy exited with code ${code}`));
+        }
+      });
+      
+      pbcopy.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Copy to clipboard on Windows
+   */
+  static async copyWindows(text) {
+    return new Promise((resolve, reject) => {
+      const clip = spawn('clip');
+      
+      clip.stdin.write(text);
+      clip.stdin.end();
+      
+      clip.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`clip exited with code ${code}`));
+        }
+      });
+      
+      clip.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Copy to clipboard on Linux
+   */
+  static async copyLinux(text) {
+    // Try xclip first, then xsel as fallback
+    try {
+      return await this.copyLinuxXclip(text);
+    } catch (error) {
+      try {
+        return await this.copyLinuxXsel(text);
+      } catch (xselError) {
+        throw new Error('Neither xclip nor xsel is available. Please install one of them.');
+      }
+    }
+  }
+
+  /**
+   * Copy using xclip
+   */
+  static async copyLinuxXclip(text) {
+    return new Promise((resolve, reject) => {
+      const xclip = spawn('xclip', ['-selection', 'clipboard']);
+      
+      xclip.stdin.write(text);
+      xclip.stdin.end();
+      
+      xclip.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`xclip exited with code ${code}`));
+        }
+      });
+      
+      xclip.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Copy using xsel
+   */
+  static async copyLinuxXsel(text) {
+    return new Promise((resolve, reject) => {
+      const xsel = spawn('xsel', ['--clipboard', '--input']);
+      
+      xsel.stdin.write(text);
+      xsel.stdin.end();
+      
+      xsel.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`xsel exited with code ${code}`));
+        }
+      });
+      
+      xsel.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Get clipboard content size info
+   */
+  static getContentInfo(text) {
+    const lines = text.split('\n').length;
+    const chars = text.length;
+    const bytes = Buffer.byteLength(text, 'utf8');
+    
+    return {
+      lines,
+      characters: chars,
+      bytes,
+      size: this.formatBytes(bytes)
+    };
+  }
+
+  /**
+   * Format bytes to human readable
+   */
+  static formatBytes(bytes) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+}
+
+module.exports = ClipboardManager;

package/test-small/package-lock.json

@@ -0,0 +1 @@
+{"name": "test-large", "version": "1.0.0"}