repomeld 3.0.0 → 3.0.2

package/package.json

@@ -1,59 +1,41 @@
 {
   "name": "repomeld",
-  "version": "3.0.0",
-  "description": "Meld your entire repo into a single file — perfect for AI context, code reviews & sharing",
+  "version": "3.0.2",
+  "description": "Meld your entire repo into a single file — perfect for AI context & code reviews",
   "main": "bin/cli.js",
   "bin": {
     "repomeld": "bin/cli.js"
   },
   "scripts": {
     "start": "node bin/cli.js",
-    "test": "node bin/cli.js --dry-run",
-    "prepublishOnly": "npm run test",
-    "postinstall": "node -e \"console.log('\\n📦 repomeld installed successfully! Run: repomeld --help\\n')\""
+    "dev": "node bin/cli.js --dry-run",
+    "test": "node bin/cli.js --dry-run --no-update-check"
+   
   },
-  "keywords": [
-    "cli",
-    "repo",
-    "file",
-    "combiner",
-    "merge",
-    "concat",
-    "ai-context",
-    "code-review",
-    "repomeld",
-    "git",
-    "repository"
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
   ],
+  "dependencies": {
+    "archiver": "^6.0.1",
+    "commander": "^11.1.0",
+    "ignore": "^5.3.0",
+    "isbinaryfile": "^5.0.0"
+  },
+  "keywords": ["cli", "repo", "combiner", "ai-context", "code-review", "mermaid", "dependency-graph"],
   "author": "Susheel <susheelhbti@gmail.com>",
   "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sakshsky/repomeld.git"
+    "url": "git+https://github.com/susheel/repomeld.git"
   },
   "bugs": {
-    "url": "https://github.com/sakshsky/repomeld/issues"
-  },
-  "homepage": "https://github.com/sakshsky/repomeld#readme",
-  "dependencies": {
-    "archiver": "^7.0.1",
-    "commander": "^11.1.0",
-    "ignore": "^5.3.2",
-    "isbinaryfile": "^5.0.7"
-  },
-  "devDependencies": {
-    "eslint": "^8.56.0",
-    "prettier": "^3.1.1"
-  },
-  "engines": {
-    "node": ">=14.0.0"
+    "url": "https://github.com/susheel/repomeld/issues"
   },
-  "files": [
-    "bin/",
-    "README.md",
-    "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+  "homepage": "https://github.com/susheel/repomeld#readme"
+}

package/src/core/fileScanner.js

@@ -0,0 +1,78 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { normalizePath } = require("../utils/constants");
+
+// Pattern to detect repomeld-related files/folders
+const REPOMELD_PATTERN = /^repomeld/i; // Case-insensitive, matches anything starting with "repomeld"
+
+async function getAllFilesWithIgnore(dirPath, ig, forceIncludePatterns) {
+  const fileList = [];
+  const stack = [{ dirPath, relativePath: '.' }];
+
+  // Pre-process force include patterns for faster matching
+  const processedPatterns = forceIncludePatterns?.map(pattern => ({
+    original: pattern,
+    clean: pattern.replace(/^\.\//, '').replace(/\/$/, ''),
+    isExact: !pattern.includes('*') && !pattern.includes('/')
+  })) || [];
+
+  while (stack.length) {
+    const { dirPath: currentDir, relativePath: currentRelative } = stack.pop();
+   
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+   
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = path.join(currentRelative, entry.name);
+      const normalizedPath = normalizePath(relativePath);
+      
+      // HARD-CODED: Always ignore any file/folder starting with "repomeld"
+      // This prevents recursive inclusion and infinite loops
+      // Also ignores repomeld_output.txt, repomeld_zips/, etc.
+      if (REPOMELD_PATTERN.test(entry.name)) {
+        continue;
+      }
+     
+      // Fast force-include check
+      let isForceIncluded = false;
+      if (processedPatterns.length) {
+        for (const pattern of processedPatterns) {
+          if (pattern.isExact) {
+            // Exact match - fastest
+            if (entry.name === pattern.clean || normalizedPath === pattern.clean) {
+              isForceIncluded = true;
+              break;
+            }
+          } else {
+            // Pattern matching
+            if (normalizedPath.includes(pattern.clean) || 
+                normalizedPath.startsWith(pattern.clean + '/') ||
+                entry.name.includes(pattern.clean)) {
+              isForceIncluded = true;
+              break;
+            }
+          }
+        }
+      }
+      
+      // Only check ignore if not force-included
+      if (!isForceIncluded && ig.ignores(normalizedPath)) {
+        continue;
+      }
+     
+      if (entry.isDirectory()) {
+        stack.push({ dirPath: fullPath, relativePath });
+      } else if (entry.isFile()) {
+        fileList.push(fullPath);
+      }
+    }
+  }
+  return fileList;
+}
+
+module.exports = { getAllFilesWithIgnore };

package/src/core/formatter.js

@@ -0,0 +1,51 @@
+const path = require("path");
+const { formatSize, getLanguage } = require("../utils/helpers");
+const { LANGUAGE_MAP } = require("../utils/constants");
+
+function buildHeader(style, relativePath, filePath, lineCount, showMeta, stats) {
+  const lang = getLanguage(filePath, LANGUAGE_MAP);
+  const meta = showMeta ? ` [${lineCount} lines | ${formatSize(stats.size)}${lang ? ` | ${lang}` : ""}]` : "";
+
+  if (style === "markdown") {
+    return `\n## 📄 ${relativePath}${meta}\n\n\`\`\`${lang}\n`;
+  }
+  if (style === "minimal") {
+    return `\n# ${relativePath}\n`;
+  }
+
+  const divider = "─".repeat(60);
+  return `\n${divider}\n FILE: ${relativePath}${meta}\n${divider}\n\n`;
+}
+
+function buildFooter(style) {
+  return style === "markdown" ? "\n```\n" : "\n";
+}
+
+function buildTableOfContents(files, cwd) {
+  let toc = "TABLE OF CONTENTS\n" + "═".repeat(60) + "\n";
+  files.forEach((f, i) => {
+    let rel = path.relative(cwd, f);
+    // Normalize to forward slashes for cross-platform consistency
+    rel = rel.split(path.sep).join('/');
+    toc += ` ${String(i + 1).padStart(3, " ")}. ${rel}\n`;
+  });
+  toc += "═".repeat(60) + "\n\n";
+  return toc;
+}
+
+function printBanner(VERSION) {
+  console.log(`
+╔══════════════════════════════════════════════════════╗
+║ repomeld v${VERSION}                                 ║
+║ Meld your repo into one file 🔥                       ║
+╠══════════════════════════════════════════════════════╣
+║ 💼 susheelhbti@gmail.com — Open for work             ║
+╚══════════════════════════════════════════════════════╝`);
+}
+
+module.exports = {
+  buildHeader,
+  buildFooter,
+  buildTableOfContents,
+  printBanner,
+};

package/src/core/ignoreBuilder.js

@@ -0,0 +1,41 @@
+const fs = require("fs").promises;
+const path = require("path");
+const ignore = require("ignore");
+const { DEFAULT_IGNORE } = require("../utils/constants");
+
+async function loadIgnoreConfig() {
+  const configPath = path.resolve(process.cwd(), "repomeld.ignore.json");
+  try {
+    const data = JSON.parse(await fs.readFile(configPath, "utf8"));
+    return Array.isArray(data.ignore) ? data.ignore : [];
+  } catch {
+    return [];
+  }
+}
+
+async function buildIgnoreFilter(options) {
+  const ig = ignore();
+  ig.add(DEFAULT_IGNORE);
+
+  const customIgnores = await loadIgnoreConfig();
+  ig.add(customIgnores);
+
+  if (options.ignore?.length) ig.add(options.ignore);
+
+  if (!options.noGitignore) {
+    try {
+      const gitignorePath = path.join(process.cwd(), ".gitignore");
+      const gitignoreContent = await fs.readFile(gitignorePath, "utf8");
+      ig.add(gitignoreContent);
+    } catch {
+      // No .gitignore file, ignore silently
+    }
+  }
+
+  // Return forceInclude as array for fileScanner
+  const forceIncludePatterns = options.forceInclude || [];
+
+  return { ig, forceIncludePatterns };
+}
+
+module.exports = { buildIgnoreFilter };

package/src/core/pathResolver.js

@@ -0,0 +1,24 @@
+const fs = require("fs").promises;
+const path = require("path");
+
+async function resolveOutputPath(desiredPath) {
+  try {
+    await fs.access(desiredPath);
+    const ext = path.extname(desiredPath);
+    const base = desiredPath.slice(0, -ext.length);
+    let counter = 2;
+    while (true) {
+      const candidate = `${base}__${counter}${ext}`;
+      try {
+        await fs.access(candidate);
+        counter++;
+      } catch {
+        return { path: candidate, number: counter };
+      }
+    }
+  } catch {
+    return { path: desiredPath, number: null };
+  }
+}
+
+module.exports = { resolveOutputPath };

package/src/core/progress.js

@@ -0,0 +1,29 @@
+const { formatDuration } = require("../utils/helpers");
+
+class ProgressIndicator {
+  constructor(total, prefix = '') {
+    this.total = total;
+    this.prefix = prefix;
+    this.current = 0;
+    this.startTime = Date.now();
+  }
+
+  update(current) {
+    this.current = current;
+    this.render();
+  }
+
+  render() {
+    if (this.current % 80 !== 0 && this.current !== this.total) return;
+    const percent = (this.current / this.total * 100).toFixed(1);
+    const elapsed = Date.now() - this.startTime;
+    console.log(`\r${this.prefix} ${this.current}/${this.total} files (${percent}%) | ${formatDuration(elapsed)} elapsed`);
+  }
+
+  finish() {
+    const elapsed = Date.now() - this.startTime;
+    console.log(`\r${this.prefix} ✅ Completed ${this.current}/${this.total} files in ${formatDuration(elapsed)}`);
+  }
+}
+
+module.exports = { ProgressIndicator };

package/src/index.js

@@ -0,0 +1,192 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { isBinaryFile } = require("isbinaryfile");
+
+const { VERSION, BINARY_EXTENSIONS } = require("./utils/constants");
+const { formatSize, formatDuration, matchesExtensions, matchesPattern } = require("./utils/helpers");
+const { buildIgnoreFilter } = require("./core/ignoreBuilder");
+const { getAllFilesWithIgnore } = require("./core/fileScanner");
+const { ProgressIndicator } = require("./core/progress");
+const { buildHeader, buildFooter, buildTableOfContents, printBanner } = require("./core/formatter");
+const { createBackupZip } = require("./utils/backup");
+const { resolveOutputPath } = require("./core/pathResolver");
+const { checkForUpdates, showUpdateMessage } = require("./updates/updateChecker");
+
+// Cache for binary detection
+const binaryCache = new Map();
+
+async function isBinaryFileFast(filePath) {
+  // Check cache first
+  if (binaryCache.has(filePath)) return binaryCache.get(filePath);
+  
+  // Quick check by extension
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) {
+    binaryCache.set(filePath, true);
+    return true;
+  }
+  
+  // Fall back to full detection
+  const result = await isBinaryFile(filePath).catch(() => true);
+  binaryCache.set(filePath, result);
+  return result;
+}
+
+async function repomeld(options) {
+  const startTime = Date.now();
+  printBanner(VERSION);
+  const cwd = process.cwd();
+
+  const { path: outputFile, number: outputNumber } = await resolveOutputPath(path.resolve(cwd, options.output));
+
+  const { ig, forceIg } = await buildIgnoreFilter(options);
+  
+  // Convert forceIg patterns to array for fileScanner
+  const forceIncludePatterns = options.forceInclude || [];
+  
+  const filterExts = options.ext || [];
+  const maxFileSizeBytes = (parseFloat(options.maxSize) || 500) * 1024;
+  const headerStyle = options.style || "banner";
+  const showMeta = !options.noMeta;
+  const showToc = !options.noToc;
+  const dryRun = !!options.dryRun;
+
+  console.log(`\n 📂 Source : ${cwd}`);
+  console.log(` 📄 Output : ${path.relative(cwd, outputFile)}`);
+  console.log(` 🎨 Style  : ${headerStyle}`);
+  if (filterExts.length) console.log(` 🔍 Filter : .${filterExts.join(", .")}`);
+  if (forceIncludePatterns.length) console.log(` 📌 Force include : ${forceIncludePatterns.join(", ")}`);
+  if (dryRun) console.log(` 🧪 Dry run mode`);
+
+  console.log(`\n 🔍 Scanning files...`);
+  let allFiles = await getAllFilesWithIgnore(cwd, ig, forceIncludePatterns);
+
+  // Apply filters
+  if (filterExts.length) allFiles = allFiles.filter(f => matchesExtensions(f, filterExts));
+  if (options.include?.length) allFiles = allFiles.filter(f => matchesPattern(f, options.include));
+  if (options.exclude?.length) allFiles = allFiles.filter(f => !matchesPattern(f, options.exclude));
+
+  // Remove previous repomeld outputs - improved pattern
+  const outputPattern = new RegExp(`^${path.basename(options.output).replace(/\.txt$/, '')}(_+?\\d+)?\\.txt$`);
+  allFiles = allFiles.filter(f => !outputPattern.test(path.basename(f)));
+
+  console.log(` ✅ Found ${allFiles.length} files\n`);
+
+  if (allFiles.length === 0) {
+    console.log(" ⚠️ No matching files found.");
+    return;
+  }
+
+  // Memory warning for large repos
+  const estimatedMemoryMB = (allFiles.length * 0.5) / 1024; // Rough estimate: 0.5KB per file path
+  if (estimatedMemoryMB > 100) {
+    console.log(` ⚠️ Large repository detected (~${allFiles.length} files). Memory usage may be high.\n`);
+  }
+
+  let combinedContent = "";
+  let skipped = 0, included = 0, totalLines = 0;
+  const includedFiles = [];
+
+  const progress = new ProgressIndicator(allFiles.length, ' Processing:');
+
+  for (let i = 0; i < allFiles.length; i++) {
+    const filePath = allFiles[i];
+    const relativePath = path.relative(cwd, filePath);
+    progress.update(i + 1);
+
+    // Use fast binary detection with caching
+    if (await isBinaryFileFast(filePath)) {
+      skipped++;
+      continue;
+    }
+
+    const stats = await fs.stat(filePath);
+    if (stats.size > maxFileSizeBytes) {
+      skipped++;
+      continue;
+    }
+
+    try {
+      let content = await fs.readFile(filePath, "utf8");
+
+      if (options.trim) content = content.trim();
+
+      if (options.linesBefore || options.linesAfter) {
+        const lines = content.split("\n");
+        const start = Math.max(0, parseInt(options.linesBefore) || 0);
+        const end = options.linesAfter 
+          ? Math.max(start, lines.length - parseInt(options.linesAfter)) 
+          : lines.length;
+        content = lines.slice(start, end).join("\n");
+      }
+
+      const lineCount = content.split("\n").length;
+      totalLines += lineCount;
+      includedFiles.push(filePath);
+
+      combinedContent += buildHeader(headerStyle, relativePath, filePath, lineCount, showMeta, stats);
+      combinedContent += content;
+      combinedContent += buildFooter(headerStyle);
+
+      included++;
+    } catch {
+      skipped++;
+    }
+  }
+
+  progress.finish();
+
+  // Final Output
+  let finalOutput = `# Generated by repomeld v${VERSION}\n`;
+  finalOutput += `# Date   : ${new Date().toISOString()}\n`;
+  finalOutput += `# Source : ${cwd}\n`;
+  finalOutput += `# Files  : ${included}\n`;
+  finalOutput += `# Lines  : ${totalLines}\n\n`;
+
+  if (showToc) finalOutput += buildTableOfContents(includedFiles, cwd);
+  finalOutput += combinedContent;
+
+  if (!dryRun) {
+    await fs.writeFile(outputFile, finalOutput, "utf8");
+  }
+
+  const outputSize = formatSize(Buffer.byteLength(finalOutput, "utf8"));
+  const totalTime = Date.now() - startTime;
+
+  console.log(`
+  ✨ repomeld complete!
+  ─────────────────────────────────────────────────
+  ✅ Included : ${included} files
+  ⏭ Skipped  : ${skipped} files
+  📏 Lines    : ${totalLines}
+  💾 Size     : ${outputSize}
+  ⏱️  Time     : ${formatDuration(totalTime)}
+  📄 Output   : ${path.relative(cwd, outputFile)}${dryRun ? " (dry run)" : ""}
+  ─────────────────────────────────────────────────`);
+
+  // Backup ZIP
+  if (!dryRun && included > 0 && options.backup !== false) {
+    console.log(`\n 📦 Creating backup zip...`);
+    try {
+      const { zipFilePath, size } = await createBackupZip(includedFiles, cwd, outputFile);
+      console.log(` ✅ Backup created: ${path.relative(cwd, zipFilePath)} (${size})`);
+    } catch (err) {
+      console.log(` ⚠️  Backup failed: ${err.message}`);
+    }
+  }
+
+  console.log(`\n 💼 Need a developer? susheelhbti@gmail.com`);
+
+  // Update check
+  if (!options.noUpdateCheck) {
+    const updateInfo = await checkForUpdates();
+    if (updateInfo.hasUpdate) {
+      showUpdateMessage(VERSION, updateInfo.latestVersion);
+    }
+  }
+  
+  // Clear binary cache to free memory
+  binaryCache.clear();
+}
+
+module.exports = { repomeld };

package/src/updates/updateChecker.js

@@ -0,0 +1,43 @@
+const https = require("https");
+const { PACKAGE_NAME, VERSION } = require("../utils/constants");
+
+async function checkForUpdates() {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      path: `/${PACKAGE_NAME}/latest`,
+      method: 'GET',
+      timeout: 4000
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.version && json.version !== VERSION) {
+            resolve({ hasUpdate: true, latestVersion: json.version });
+          } else {
+            resolve({ hasUpdate: false });
+          }
+        } catch {
+          resolve({ hasUpdate: false });
+        }
+      });
+    });
+
+    req.on('error', () => resolve({ hasUpdate: false }));
+    req.on('timeout', () => { req.destroy(); resolve({ hasUpdate: false }); });
+    req.end();
+  });
+}
+
+function showUpdateMessage(currentVersion, latestVersion) {
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log(` ⭐ New version available: ${currentVersion} → ${latestVersion}`);
+  console.log(` 📦 Update: npm install -g ${PACKAGE_NAME}@latest`);
+  console.log(`${'═'.repeat(60)}\n`);
+}
+
+module.exports = { checkForUpdates, showUpdateMessage };

package/src/utils/backup.js

@@ -0,0 +1,48 @@
+const fs = require("fs");
+const path = require("path");
+const archiver = require("archiver");
+const { formatSize } = require("./helpers");
+
+function resolveZipPath(outputPath) {
+  const outputFileName = path.basename(outputPath);
+  const outputBaseName = outputFileName.replace(/\.txt$/, '');
+  const zipDir = path.join(process.cwd(), "repomeld_zips");
+
+  if (!fs.existsSync(zipDir)) {
+    fs.mkdirSync(zipDir, { recursive: true });
+  }
+
+  return path.join(zipDir, `${outputBaseName}.zip`);
+}
+
+async function createBackupZip(files, cwd, outputFilePath) {
+  const zipFilePath = resolveZipPath(outputFilePath);
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(zipFilePath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+
+    output.on('close', () => {
+      resolve({
+        zipFilePath,
+        size: formatSize(archive.pointer()),
+        fileCount: files.length
+      });
+    });
+
+    archive.on('error', reject);
+    archive.pipe(output);
+
+    for (const filePath of files) {
+      const relativePath = path.relative(cwd, filePath);
+      archive.file(filePath, { name: relativePath });
+    }
+
+    if (fs.existsSync(outputFilePath)) {
+      archive.file(outputFilePath, { name: path.basename(outputFilePath) });
+    }
+
+    archive.finalize();
+  });
+}
+
+module.exports = { createBackupZip };

package/src/utils/constants.js

@@ -0,0 +1,40 @@
+const path = require("path");
+
+// Normalize paths for cross-platform compatibility
+const normalizePath = (p) => p.split(path.sep).join('/');
+
+const VERSION = "1.2.0";  // Updated to match output
+const PACKAGE_NAME = "repomeld";
+
+const DEFAULT_IGNORE = [
+  "node_modules", ".git", ".env", ".env.local", ".env.production",
+  ".DS_Store", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+  ".next", ".nuxt", "dist", "build", ".cache"
+];
+
+const LANGUAGE_MAP = {
+  js: "javascript", jsx: "javascript", ts: "typescript", tsx: "typescript",
+  py: "python", rb: "ruby", java: "java", cpp: "cpp", c: "c",
+  cs: "csharp", go: "go", rs: "rust", php: "php", swift: "swift",
+  kt: "kotlin", html: "html", css: "css", scss: "scss", json: "json",
+  yaml: "yaml", yml: "yaml", md: "markdown", sh: "bash", bash: "bash",
+  toml: "toml", xml: "xml", sql: "sql", graphql: "graphql",
+};
+
+// Binary extensions cache for performance
+const BINARY_EXTENSIONS = new Set([
+  'jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg',
+  'pdf', 'zip', 'tar', 'gz', '7z', 'rar',
+  'mp3', 'mp4', 'avi', 'mov', 'wav',
+  'exe', 'dll', 'so', 'dylib',
+  'woff', 'woff2', 'ttf', 'eot', 'otf'
+]);
+
+module.exports = {
+  normalizePath,
+  VERSION,
+  PACKAGE_NAME,
+  DEFAULT_IGNORE,
+  LANGUAGE_MAP,
+  BINARY_EXTENSIONS,
+};

package/src/utils/helpers.js

@@ -0,0 +1,37 @@
+const path = require("path");
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+function formatDuration(ms) {
+  return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+function matchesExtensions(filePath, exts) {
+  if (!exts?.length) return true;
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  return exts.map(e => e.replace(/^\./, "").toLowerCase()).includes(ext);
+}
+
+function matchesPattern(filePath, patterns) {
+  if (!patterns?.length) return false;
+  const rel = path.relative(process.cwd(), filePath);
+  return patterns.some(p => rel.includes(p) || path.basename(filePath).includes(p));
+}
+
+function getLanguage(filePath, LANGUAGE_MAP) {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  return LANGUAGE_MAP[ext] || "";
+}
+
+module.exports = {
+  formatSize,
+  formatDuration,
+  matchesExtensions,
+  matchesPattern,
+  getLanguage,
+};