condensed/dist/index.js

A CLI tool to compile files from a folder into a single file or clipboard

import fs from "fs-extra";
import * as path from "path";
import ignore from "ignore";
import clipboardy from "clipboardy";
import { program } from "commander";
class FolderCompiler {
    baseFolder;
    outputFile;
    ignoreFilter;
    constructor(baseFolder, outputFile) {
        this.baseFolder = path.resolve(baseFolder);
        this.outputFile = outputFile ? path.resolve(outputFile) : undefined;
        this.ignoreFilter = ignore();
        this.loadIgnoreRules();
        this.addAdditionalIgnorePatterns([".git/"]);
    }
    loadIgnoreRules() {
        const gitignorePath = path.join(this.baseFolder, ".gitignore");
        try {
            if (fs.existsSync(gitignorePath)) {
                const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
                this.ignoreFilter.add(gitignoreContent.split(/\r?\n/));
            }
        }
        catch (error) {
            console.warn("Could not read .gitignore file:", error);
        }
    }
    addAdditionalIgnorePatterns(patterns) {
        this.ignoreFilter.add(patterns);
    }
    walkDir(dir) {
        const entries = fs.readdirSync(dir, { withFileTypes: true });
        const fileEntries = [];
        for (const entry of entries) {
            const fullPath = path.join(dir, entry.name);
            const relPath = path.relative(this.baseFolder, fullPath);
            if (this.ignoreFilter.ignores(relPath)) {
                continue;
            }
            if (entry.isDirectory()) {
                fileEntries.push(...this.walkDir(fullPath));
            }
            else if (entry.isFile()) {
                fileEntries.push(fullPath);
            }
        }
        return fileEntries;
    }
    compile(options = {}) {
        const fileEntries = this.walkDir(this.baseFolder);
        let compiledOutput = "";
        fileEntries.forEach((filePath) => {
            const relPath = path
                .relative(this.baseFolder, filePath)
                .replace(/\\/g, "/");
            const fileContent = fs.readFileSync(filePath, "utf8");
            compiledOutput += `// File: ${relPath}\n${fileContent}\n\n`;
        });
        if (options.clipboard) {
            clipboardy.writeSync(compiledOutput);
            console.log(`Copied ${fileEntries.length} files to clipboard`);
        }
        if (this.outputFile) {
            fs.writeFileSync(this.outputFile, compiledOutput, "utf8");
            console.log(`Compiled ${fileEntries.length} files into ${this.outputFile}`);
        }
        return compiledOutput;
    }
}
function main() {
    program
        .name("folder-compiler")
        .description("Compile files from a folder into a single file or clipboard")
        .argument("<folder>", "Source folder to compile")
        .option("-o, --output <file>", "Output file path")
        .option("-i, --ignore <patterns>", "Additional ignore patterns (comma-separated)")
        .option("-c, --clipboard", "Copy output to clipboard")
        .action((folder, options) => {
        try {
            const compiler = new FolderCompiler(folder, options.output);
            if (options.ignore) {
                const additionalIgnorePatterns = options.ignore.split(",");
                compiler.addAdditionalIgnorePatterns(additionalIgnorePatterns);
            }
            compiler.compile({
                clipboard: options.clipboard,
                additionalIgnore: options.ignore ? options.ignore.split(",") : [],
            });
        }
        catch (error) {
            console.error("Error:", error);
            process.exit(1);
        }
    });
    program.parse(process.argv);
}
export default main;