feat: add ll-cli analyze size subcommand

Add a new `analyze size` subcommand to ll-cli that reports on-disk usage
of installed layers, breaking each module's footprint into:

- exclusive: bytes unique to that module
- shared:    bytes shared with at least one other module
- logical:   exclusive + shared (apparent size to the module)
- actual:    shared bytes divided across the sharing modules

Sizes are computed from st_blocks (real block usage, not file size),
and hard-linked inodes are deduplicated by (st_dev, st_ino) so they
are counted once per sharing module. A separate pass reports the
total real disk usage of the repository directory for cross-reference.

Options:
  --sort {actual|logical|exclusive|shared|id}  (default: actual)
  --asc                                        (default: descending)

Signed-off-by: reddevillg <reddevillg@gmail.com>

Author: reddevillg

apps/ll-cli/src/main.cpp

@@ -432,6 +432,40 @@ ll-cli list --upgradable
                         "application(s), base(s) or runtime(s)"));
 }
 
+// Function to add the analyze size subcommand
+void addAnalyzeSizeCommand(CLI::App &cliAnalyze, SizeOptions &sizeOptions)
+{
+    auto *cliSize =
+      cliAnalyze.add_subcommand("size", _("Show installed module sizes and repository real size"))
+        ->fallthrough();
+    cliSize->usage(_(R"(Usage: ll-cli analyze size [OPTIONS]
+
+Example:
+# show installed module sizes
+ll-cli analyze size
+)"));
+    cliSize
+      ->add_option(
+        "--sort",
+        sizeOptions.sortBy,
+        _(R"(Sort result by specify field. One of "actual", "logical", "exclusive", "shared" or "id")"))
+      ->type_name("FIELD")
+      ->capture_default_str()
+      ->check(CLI::IsMember({ "actual", "logical", "exclusive", "shared", "id" }));
+    cliSize->add_flag("--asc", sizeOptions.ascending, _("Sort in ascending order"));
+}
+
+// Function to add the analyze subcommands
+void addAnalyzeCommand(CLI::App &commandParser, SizeOptions &sizeOptions, const std::string &group)
+{
+    auto *cliAnalyze = commandParser.add_subcommand("analyze", _("Analyze installed applications"))
+                         ->group(group)
+                         ->usage(_("Usage: ll-cli analyze SUBCOMMAND [OPTIONS]"));
+    cliAnalyze->require_subcommand(1);
+
+    addAnalyzeSizeCommand(*cliAnalyze, sizeOptions);
+}
+
 // Function to add the info subcommand
 void addInfoCommand(CLI::App &commandParser, InfoOptions &infoOptions, const std::string &group)
 {
@@ -566,6 +600,7 @@ You can report bugs to the linyaps team under this project: https://github.com/O
     SearchOptions searchOptions{};
     UninstallOptions uninstallOptions{};
     ListOptions listOptions{};
+    SizeOptions sizeOptions{};
     InfoOptions infoOptions{};
     ContentOptions contentOptions{};
     linglong::common::cli::RepoOptions repoOptions{};
@@ -587,6 +622,7 @@ You can report bugs to the linyaps team under this project: https://github.com/O
     addUpgradeCommand(commandParser, upgradeOptions, CliBuildInGroup);
     addSearchCommand(commandParser, searchOptions, CliSearchGroup);
     addListCommand(commandParser, listOptions, CliBuildInGroup);
+    addAnalyzeCommand(commandParser, sizeOptions, CliBuildInGroup);
     linglong::common::cli::addRepoCommand(commandParser,
                                           repoOptions,
                                           CliRepoGroup,
@@ -743,6 +779,14 @@ You can report bugs to the linyaps team under this project: https://github.com/O
         result = cli->uninstall(uninstallOptions);
     } else if (name == "list") {
         result = cli->list(listOptions);
+    } else if (name == "analyze") {
+        const auto &subcommands = (*ret)->get_subcommands();
+        auto subcommand = std::find_if(subcommands.begin(), subcommands.end(), [](CLI::App *app) {
+            return app->parsed();
+        });
+        if (subcommand != subcommands.end() && (*subcommand)->get_name() == "size") {
+            result = cli->size(sizeOptions);
+        }
     } else if (name == "info") {
         result = cli->info(infoOptions);
     } else if (name == "content") {

libs/linglong/src/linglong/cli/cli.cpp

@@ -68,12 +68,15 @@
 #include <string>
 #include <system_error>
 #include <thread>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
 #include <fcntl.h>
 #include <pwd.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <unistd.h>
 
 using namespace linglong::utils::error;
@@ -283,6 +286,169 @@ bool delegateToContainerInit(const std::string &containerID,
     return result == 0;
 }
 
+struct ModuleSize
+{
+    std::uint64_t exclusiveSize{ 0 };
+    std::uint64_t sharedSize{ 0 };
+    std::uint64_t logicalSize{ 0 };
+    std::uint64_t actualSize{ 0 };
+};
+
+struct InodeUsage
+{
+    std::uint64_t diskUsage{ 0 };
+    std::unordered_set<std::size_t> modules;
+};
+
+struct ModuleSizeCalculation
+{
+    std::vector<ModuleSize> moduleSizes;
+    std::uint64_t actualTotalSize{ 0 };
+};
+
+Result<ModuleSizeCalculation>
+calculateModuleSizes(const std::vector<std::filesystem::path> &moduleDirs) noexcept
+{
+    LINGLONG_TRACE("calculate module sizes");
+
+    std::unordered_map<std::string, InodeUsage> inodeUsages;
+    std::error_code ec;
+
+    auto addEntry = [&](const std::filesystem::path &path,
+                        std::size_t moduleIndex) -> Result<void> {
+        struct stat64 st{};
+        if (::lstat64(path.c_str(), &st) == -1) {
+            const auto err = errno;
+            return LINGLONG_ERR(fmt::format("failed to stat {}: {}",
+                                            path,
+                                            linglong::common::error::errorString(err)));
+        }
+
+        const auto diskUsage = static_cast<std::uint64_t>(st.st_blocks) * 512;
+        const auto inodeKey = std::to_string(st.st_dev) + ":" + std::to_string(st.st_ino);
+
+        auto &usage = inodeUsages[inodeKey];
+        usage.diskUsage = diskUsage;
+        usage.modules.insert(moduleIndex);
+
+        return LINGLONG_OK;
+    };
+
+    for (std::size_t moduleIndex = 0; moduleIndex < moduleDirs.size(); ++moduleIndex) {
+        const auto &dir = moduleDirs[moduleIndex];
+        auto addRoot = addEntry(dir, moduleIndex);
+        if (!addRoot) {
+            return LINGLONG_ERR(addRoot);
+        }
+
+        auto iterator = std::filesystem::recursive_directory_iterator{
+            dir,
+            std::filesystem::directory_options::skip_permission_denied,
+            ec
+        };
+        if (ec) {
+            return LINGLONG_ERR(fmt::format("failed to open module directory {}", dir), ec);
+        }
+
+        const auto end = std::filesystem::recursive_directory_iterator{};
+        while (iterator != end) {
+            const auto &entry = *iterator;
+            auto addResult = addEntry(entry.path(), moduleIndex);
+            if (!addResult) {
+                return LINGLONG_ERR(addResult);
+            }
+
+            iterator.increment(ec);
+            if (ec) {
+                return LINGLONG_ERR(fmt::format("failed to iterate module directory {}", dir), ec);
+            }
+        }
+    }
+
+    ModuleSizeCalculation calculation;
+    calculation.moduleSizes.resize(moduleDirs.size());
+    for (const auto &[_, usage] : inodeUsages) {
+        const auto moduleCount = usage.modules.size();
+        if (moduleCount == 0) {
+            continue;
+        }
+
+        calculation.actualTotalSize += usage.diskUsage;
+        const auto actualSize = usage.diskUsage / moduleCount;
+        for (auto moduleIndex : usage.modules) {
+            auto &moduleSize = calculation.moduleSizes[moduleIndex];
+            moduleSize.logicalSize += usage.diskUsage;
+            if (moduleCount == 1) {
+                moduleSize.exclusiveSize += usage.diskUsage;
+                moduleSize.actualSize += usage.diskUsage;
+            } else {
+                moduleSize.sharedSize += usage.diskUsage;
+                moduleSize.actualSize += actualSize;
+            }
+        }
+    }
+
+    return calculation;
+}
+
+Result<std::uint64_t> calculateRealDiskUsage(const std::filesystem::path &dir) noexcept
+{
+    LINGLONG_TRACE("calculate real disk usage");
+
+    std::uint64_t size{ 0 };
+    std::unordered_set<std::string> visitedInodes;
+
+    auto addPath = [&](const std::filesystem::path &path) -> Result<void> {
+        struct stat64 st{};
+
+        if (::lstat64(path.c_str(), &st) == -1) {
+            const auto err = errno;
+            return LINGLONG_ERR(fmt::format("failed to stat {}: {}",
+                                            path,
+                                            linglong::common::error::errorString(err)));
+        }
+
+        const auto inodeKey = std::to_string(st.st_dev) + ":" + std::to_string(st.st_ino);
+        if (st.st_nlink > 1 && !visitedInodes.insert(inodeKey).second) {
+            return LINGLONG_OK;
+        }
+
+        size += static_cast<std::uint64_t>(st.st_blocks) * 512;
+        return LINGLONG_OK;
+    };
+
+    auto rootResult = addPath(dir);
+    if (!rootResult) {
+        return LINGLONG_ERR(rootResult);
+    }
+
+    std::error_code ec;
+    auto iterator = std::filesystem::recursive_directory_iterator{
+        dir,
+        std::filesystem::directory_options::skip_permission_denied,
+        ec
+    };
+    if (ec) {
+        return LINGLONG_ERR(fmt::format("failed to open repository directory {}", dir), ec);
+    }
+
+    const auto end = std::filesystem::recursive_directory_iterator{};
+    while (iterator != end) {
+        const auto &entry = *iterator;
+        auto result = addPath(entry.path());
+        if (!result) {
+            return LINGLONG_ERR(result);
+        }
+
+        iterator.increment(ec);
+        if (ec) {
+            return LINGLONG_ERR(fmt::format("failed to iterate repository directory {}", dir), ec);
+        }
+    }
+
+    return size;
+}
+
 } // namespace
 
 namespace linglong::cli {
@@ -1679,6 +1845,107 @@ int Cli::list(const ListOptions &options)
     return 0;
 }
 
+int Cli::size(const SizeOptions &options)
+{
+    auto repo = this->getRepo();
+    if (!repo) {
+        this->printer.printErr(repo.error());
+        return -1;
+    }
+
+    auto items = (*repo)->listLayerItem();
+    if (!items) {
+        this->printer.printErr(items.error());
+        return -1;
+    }
+
+    std::vector<Printer::ModuleSizeInfo> moduleSizes;
+    moduleSizes.reserve(items->size());
+    std::vector<std::filesystem::path> modulePaths;
+    modulePaths.reserve(items->size());
+
+    for (const auto &item : *items) {
+        if (item.deleted.value_or(false)) {
+            continue;
+        }
+
+        auto ref = package::Reference::fromPackageInfo(item.info);
+        if (!ref) {
+            this->printer.printErr(ref.error());
+            return -1;
+        }
+
+        auto layerDir = (*repo)->getLayerDir(*ref, item.info.packageInfoV2Module);
+        if (!layerDir) {
+            this->printer.printErr(layerDir.error());
+            return -1;
+        }
+
+        moduleSizes.push_back(Printer::ModuleSizeInfo{
+          .id = item.info.id,
+          .name = item.info.name,
+          .version = item.info.version,
+          .channel = item.info.channel,
+          .module = item.info.packageInfoV2Module,
+        });
+        modulePaths.push_back(layerDir->path());
+    }
+
+    auto calculatedSizes = calculateModuleSizes(modulePaths);
+    if (!calculatedSizes) {
+        this->printer.printErr(calculatedSizes.error());
+        return -1;
+    }
+
+    for (std::size_t index = 0; index < moduleSizes.size(); ++index) {
+        moduleSizes[index].exclusiveSize = calculatedSizes->moduleSizes.at(index).exclusiveSize;
+        moduleSizes[index].sharedSize = calculatedSizes->moduleSizes.at(index).sharedSize;
+        moduleSizes[index].logicalSize = calculatedSizes->moduleSizes.at(index).logicalSize;
+        moduleSizes[index].actualSize = calculatedSizes->moduleSizes.at(index).actualSize;
+    }
+
+    const auto tieByName = [](const auto &info) {
+        return std::tie(info.id, info.channel, info.module, info.version);
+    };
+    std::sort(moduleSizes.begin(),
+              moduleSizes.end(),
+              [&options, &tieByName](const auto &lhs, const auto &rhs) {
+                  auto compareSize = [&options, &tieByName, &lhs, &rhs](std::uint64_t lhsSize,
+                                                                        std::uint64_t rhsSize) {
+                      if (lhsSize == rhsSize) {
+                          return tieByName(lhs) < tieByName(rhs);
+                      }
+
+                      return options.ascending ? lhsSize < rhsSize : lhsSize > rhsSize;
+                  };
+
+                  if (options.sortBy == "id") {
+                      return options.ascending ? tieByName(lhs) < tieByName(rhs)
+                                               : tieByName(rhs) < tieByName(lhs);
+                  }
+                  if (options.sortBy == "logical") {
+                      return compareSize(lhs.logicalSize, rhs.logicalSize);
+                  }
+                  if (options.sortBy == "exclusive") {
+                      return compareSize(lhs.exclusiveSize, rhs.exclusiveSize);
+                  }
+                  if (options.sortBy == "shared") {
+                      return compareSize(lhs.sharedSize, rhs.sharedSize);
+                  }
+
+                  return compareSize(lhs.actualSize, rhs.actualSize);
+              });
+
+    auto repoSize = calculateRealDiskUsage((*repo)->getRepoDir());
+    if (!repoSize) {
+        this->printer.printErr(repoSize.error());
+        return -1;
+    }
+
+    this->printer.printModuleSizes(moduleSizes, calculatedSizes->actualTotalSize, *repoSize);
+    return 0;
+}
+
 utils::error::Result<std::vector<api::types::v1::UpgradeListResult>> Cli::listUpgradable()
 {
     LINGLONG_TRACE("list upgradable");

libs/linglong/src/linglong/cli/cli.h

@@ -117,6 +117,12 @@ struct ListOptions
     bool showUpgradeList{ false };
 };
 
+struct SizeOptions
+{
+    std::string sortBy{ "actual" };
+    bool ascending{ false };
+};
+
 struct InfoOptions
 {
     std::string appid;
@@ -181,6 +187,7 @@ class Cli : public QObject
     int search(const SearchOptions &options);
     int uninstall(const UninstallOptions &options);
     int list(const ListOptions &options);
+    int size(const SizeOptions &options);
     int repo(CLI::App *subcommand, const common::cli::RepoOptions &options);
     int info(const InfoOptions &options);
     int content(const ContentOptions &options);