{

#ifdef _WIN32

const char *home = vix::utils::vix_getenv("USERPROFILE");

#else

const char *home = vix::utils::vix_getenv("HOME");

#endif

return home ? std::string(home) : std::string();

{

const std::string h = home_dir();

if (h.empty())

return fs::path(".vix");

return fs::path(h) / ".vix";

{

std::ifstream in(p);

if (!in)

throw std::runtime_error("cannot open: " + p.string());

json j;

in >> j;

return j;

{

// "namespace/name" -> "namespace.name"

const auto pos = id.find('/');

if (pos == std::string::npos)

return {};

const std::string ns = id.substr(0, pos);

const std::string name = id.substr(pos + 1);

if (ns.empty() || name.empty())

return {};

return ns + "." + name;

{

std::uintmax_t total = 0;

std::error_code ec;

if (!fs::exists(p, ec))

return 0;

for (auto it = fs::recursive_directory_iterator(

p, fs::directory_options::skip_permission_denied, ec);

it != fs::recursive_directory_iterator(); it.increment(ec))

{

if (ec)

continue;

std::error_code ec2;

if (it->is_regular_file(ec2))

{

const auto sz = it->file_size(ec2);

if (!ec2)

total += sz;

}

}

return total;

{

const char *units[] = {"B", "KB", "MB", "GB", "TB"};

double v = static_cast<double>(bytes);

int u = 0;

while (v >= 1024.0 && u < 4)

{

v /= 1024.0;

++u;

}

// simple formatting: no <iomanip> needed

char buf[64];

if (u == 0)

std::snprintf(buf, sizeof(buf), "%llu %s",

static_cast<unsigned long long>(bytes), units[u]);

else

std::snprintf(buf, sizeof(buf), "%.2f %s", v, units[u]);

return std::string(buf);

{

std::string pkg;

std::string commit;

bool operator==(const KeepKey &o) const noexcept

{

return pkg == o.pkg && commit == o.commit;

}

{

std::size_t operator()(const KeepKey &k) const noexcept

{

std::hash<std::string> h;

return (h(k.pkg) * 1315423911u) ^ h(k.commit);

}

{

vix::cli::util::section(std::cout, "Store");

vix::cli::util::kv(std::cout, "root", store_root_git().string());

return 0;

{

const fs::path root = store_root_git();

const fs::path lockP = lock_path();

vix::cli::util::section(std::cout, "Store GC");

vix::cli::util::kv(std::cout, "scope", "project");

vix::cli::util::kv(std::cout, "lock", lockP.string());

vix::cli::util::kv(std::cout, "root", root.string());

if (dryRun)

vix::cli::util::kv(std::cout, "mode", "dry-run");

if (!fs::exists(lockP))

{

vix::cli::util::err_line(std::cerr, "missing lock file: " + lockP.string());

vix::cli::util::warn_line(std::cerr, "Tip: run in a project folder containing vix.lock");

return 1;

}

vix::cli::util::warn_line(std::cerr, "WARNING: This will remove any store entries NOT used by THIS project.");

vix::cli::util::warn_line(std::cerr, "If you have other Vix projects, their cached dependencies might be deleted.");

std::cerr << "\n";

if (!fs::exists(root))

{

vix::cli::util::ok_line(std::cout, "GC done (store empty).");

return 0;

}

json lock;

try

{

lock = read_json_or_throw(lockP);

}

catch (const std::exception &ex)

{

vix::cli::util::err_line(std::cerr, std::string("failed to read lock: ") + ex.what());

return 1;

}

const json *depsPtr = get_deps_ptr(lock);

if (!depsPtr)

{

vix::cli::util::err_line(std::cerr, "invalid lock: expected array or { dependencies: [] }");

return 1;

}

std::unordered_set<KeepKey, KeepKeyHash> keep;

for (const auto &d : *depsPtr)

{

const std::string id = d.value("id", "");

const std::string commit = d.value("commit", "");

const std::string pkg = pkg_dir_from_id(id);

if (pkg.empty() || commit.empty())

continue;

keep.insert(KeepKey{pkg, commit});

}

std::size_t removedCommits = 0;

std::size_t removedPackages = 0;

std::uintmax_t freed = 0;

std::error_code ec;

for (const auto &pkgIt : fs::directory_iterator(root, fs::directory_options::skip_permission_denied, ec))

{

if (ec)

break;

if (!pkgIt.is_directory())

continue;

const fs::path pkgDir = pkgIt.path();

const std::string pkgName = pkgDir.filename().string();

std::vector<fs::path> commitsToRemove;

std::error_code ec2;

for (const auto &cIt : fs::directory_iterator(pkgDir, fs::directory_options::skip_permission_denied, ec2))

{

if (ec2)

break;

if (!cIt.is_directory())

continue;

const fs::path commitDir = cIt.path();

const std::string sha = commitDir.filename().string();

if (keep.find(KeepKey{pkgName, sha}) == keep.end())

commitsToRemove.push_back(commitDir);

}

for (const auto &cdir : commitsToRemove)

{

const auto sz = dir_size_bytes(cdir);

freed += sz;

if (!dryRun)

{

std::error_code rmec;

fs::remove_all(cdir, rmec);

if (!rmec)

{

vix::cli::util::info_line(std::cout, "removed: " + pkgName + " [" + cdir.filename().string().substr(0, 8) + "...]");

++removedCommits;

}

}

else

{

vix::cli::util::info_line(std::cout, "would remove: " + pkgName + " [" + cdir.filename().string().substr(0, 8) + "...]");

++removedCommits;

}

}

// If package dir empty -> remove it

if (!dryRun)

{

std::error_code ec3;

const bool empty = fs::is_empty(pkgDir, ec3);

if (!ec3 && empty)

{

std::error_code rmec2;

fs::remove(pkgDir, rmec2);

if (!rmec2)

++removedPackages;

}

}

}

vix::cli::util::one_line_spacer(std::cout);

vix::cli::util::ok_line(std::cout, dryRun ? "GC dry-run finished." : "GC finished.");

vix::cli::util::kv(std::cout, dryRun ? "would remove commits" : "removed commits", std::to_string(removedCommits));

vix::cli::util::kv(std::cout, dryRun ? "would remove packages" : "removed packages", std::to_string(removedPackages));

vix::cli::util::kv(std::cout, dryRun ? "would free" : "freed", human_bytes(freed));

return 0;

{

if (args.empty())

return help();

const std::string sub = args[0];

if (sub == "path")

return store_path();

if (sub == "gc")

{

bool dryRun = false;

bool projectScope = false;

for (std::size_t i = 1; i < args.size(); ++i)

{

if (args[i] == "--dry-run")

dryRun = true;

else if (args[i] == "--project")

projectScope = true;

}

if (!projectScope)

{

vix::cli::util::err_line(std::cerr, "GC requires --project scope in this version.");

vix::cli::util::warn_line(std::cerr, "Use: vix store gc --project");

return 1;

}

return store_gc_project(dryRun);

}

vix::cli::util::err_line(std::cerr, "unknown store subcommand: " + sub);

vix::cli::util::warn_line(std::cerr, "Try: vix store path");

vix::cli::util::warn_line(std::cerr, "Try: vix store gc --project");

return help();

{

std::cout

<< "Usage:\n"

<< " vix store <subcommand> [options]\n\n"

<< "Subcommands:\n"

<< " path Print local store root path\n"

<< " gc Garbage collect the store\n\n"

<< "GC Options:\n"

<< " --project Scope GC to the current project (uses vix.lock)\n"

<< " --dry-run List files that would be removed without deleting them\n\n"

<< "Notes:\n"

<< " - GC --project keeps commits referenced by ./vix.lock\n"

<< " - WARNING: GC --project is destructive for other projects sharing the same store.\n";

return 0;