get_file_structure.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <unordered_set>
#include <filesystem>
#include <vector>

namespace fs = std::filesystem;

// Load .gitignore patterns into a set
std::unordered_set<std::string> load_gitignore(const fs::path& root) {
    std::unordered_set<std::string> ignores;
    ignores.insert(".git"); // always ignore .git

    std::ifstream file((root / ".gitignore").string());
    std::string line;
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        ignores.insert(line);
    }
    return ignores;
}

// Check if a path should be ignored
bool is_ignored(const fs::path& p, const std::unordered_set<std::string>& ignores) {
    std::string filename = p.filename().string();
    std::string pathStr = p.string();
    for (const auto& pattern : ignores) {
        if (filename == pattern || pathStr.find(pattern) != std::string::npos) {
            return true;
        }
    }
    return false;
}

// Recursively build JSON structure
void build_json(const fs::path& root,
                const std::unordered_set<std::string>& ignores,
                std::ostream& out,
                int depth = 0) {
    out << "{";
    bool first = true;

    // Collect files separately
    std::vector<std::string> files;

    for (const auto& entry : fs::directory_iterator(root)) {
        if (is_ignored(entry.path(), ignores)) continue;

        std::string name = entry.path().filename().string();
        if (fs::is_directory(entry)) {
            if (!first) out << ",";
            first = false;
            out << "\"" << name << "\":";
            build_json(entry.path(), ignores, out, depth + 1);
        } else {
            files.push_back(name);
        }
    }

    // Add files array if any
    if (!files.empty()) {
        if (!first) out << ",";
        out << "\"files\":[";
        for (size_t i = 0; i < files.size(); ++i) {
            if (i > 0) out << ",";
            out << "\"" << files[i] << "\"";
        }
        out << "]";
    }

    out << "}";
}

int main(int argc, char* argv[]) {
    fs::path root = (argc > 1) ? argv[1] : fs::current_path();
    auto ignores = load_gitignore(root);

    std::ofstream out(root / "structure.jsonc");
    out << "{ \"" << root.filename().string() << "\":";
    build_json(root, ignores, out);
    out << "}" << std::endl;

    std::cout << "Project structure written to " << (root / "structure.jsonc").string() << "\n";
    return 0;
}