chore: cleanup

Author: sangjanai

engine/cli/command_line_parser.cc

@@ -124,14 +124,14 @@ bool CommandLineParser::SetupCommand(int argc, char** argv) {
     }
   }
 #endif
-  // auto config = file_manager_utils::GetCortexConfig();
-  // if (!config.llamacppVersion.empty() &&
-  //     config.latestLlamacppRelease != config.llamacppVersion) {
-  //   CLI_LOG(
-  //       "\nNew llama.cpp version available: " << config.latestLlamacppRelease);
-  //   CLI_LOG("To update, run: " << commands::GetCortexBinary()
-  //                              << " engines update llama-cpp");
-  // }
+  auto config = file_manager_utils::GetCortexConfig();
+  if (!config.llamacppVersion.empty() &&
+      config.latestLlamacppRelease != config.llamacppVersion) {
+    CLI_LOG(
+        "\nNew llama.cpp version available: " << config.latestLlamacppRelease);
+    CLI_LOG("To update, run: " << commands::GetCortexBinary()
+                               << " engines update llama-cpp");
+  }
 
   return true;
 }

engine/cli/commands/cortex_upd_cmd.cc

@@ -515,10 +515,10 @@ bool CortexUpdCmd::GetLinuxInstallScript(const std::string& v,
                                          const std::string& channel) {
   std::vector<std::string> path_list;
   if (channel == "nightly") {
-    path_list = {"menloresearch",     "cortex.cpp", "dev",       "engine",
+    path_list = {kMenloOrg,     "cortex.cpp", "dev",       "engine",
                  "templates", "linux",      "install.sh"};
   } else {
-    path_list = {"menloresearch",     "cortex.cpp", "main",      "engine",
+    path_list = {kMenloOrg,     "cortex.cpp", "main",      "engine",
                  "templates", "linux",      "install.sh"};
   }
   auto url_obj = url_parser::Url{

engine/cli/commands/cortex_upd_cmd.h

@@ -79,9 +79,9 @@ inline std::vector<std::string> GetReleasePath() {
   if (CORTEX_VARIANT == file_manager_utils::kNightlyVariant) {
     return {"cortex", "latest", "version.json"};
   } else if (CORTEX_VARIANT == file_manager_utils::kBetaVariant) {
-    return {"repos", "menloresearch", "cortex.cpp", "releases"};
+    return {"repos", kMenloOrg, "cortex.cpp", "releases"};
   } else {
-    return {"repos", "menloresearch", "cortex.cpp", "releases", "latest"};
+    return {"repos", kMenloOrg, "cortex.cpp", "releases", "latest"};
   }
 }
 

engine/cli/main.cc

@@ -148,14 +148,14 @@ int main(int argc, char* argv[]) {
         std::chrono::hours(24);
     should_check_for_latest_llamacpp_version = now > last_check;
   }
-
-  if (false) {
+  
+  if (should_check_for_latest_llamacpp_version) {
     std::thread t1([]() {
       // TODO: namh current we only check for llamacpp. Need to add support for other engine
       auto get_latest_version = []() -> cpp::result<std::string, std::string> {
         try {
           auto res = github_release_utils::GetReleaseByVersion(
-              "menloresearch", "cortex.llamacpp", "latest");
+              kGgmlOrg, "llama.cpp", "latest");
           if (res.has_error()) {
             CTL_ERR("Failed to get latest llama.cpp version: " << res.error());
             return cpp::fail("Failed to get latest llama.cpp version: " +
@@ -171,6 +171,7 @@ int main(int argc, char* argv[]) {
       };
 
       auto res = get_latest_version();
+      
       if (res.has_error()) {
         CTL_ERR("Failed to get latest llama.cpp version: " << res.error());
         return;

engine/extensions/local-engine/local_engine.cc

@@ -530,21 +530,21 @@ void LocalEngine::LoadModel(std::shared_ptr<Json::Value> json_body,
 
   std::vector<std::string> v;
   v.reserve(params.size() + 1);
-  auto engine_dir = engine_service_.GetEngineDirPath("llama.cpp");
+  auto engine_dir = engine_service_.GetEngineDirPath(kLlamaRepo);
   if (engine_dir.has_error()) {
     CTL_WRN(engine_dir.error());
     server_map_.erase(model_id);
     return;
   }
-  auto exe = (engine_dir.value().first / "llama-server").string();
+  auto exe = (engine_dir.value().first / kLlamaServer).string();
 
   v.push_back(exe);
   v.insert(v.end(), params.begin(), params.end());
   engine_service_.RegisterEngineLibPath();
 
   auto log_path =
       (file_manager_utils::GetCortexLogPath() / "logs" / "cortex.log").string();
-  CTL_INF("log: " << log_path);
+  CTL_DBG("log: " << log_path);
   auto result = cortex::process::SpawnProcess(v, log_path, log_path);
   if (result.has_error()) {
     CTL_ERR("Fail to spawn process. " << result.error());

engine/services/engine_service.cc

@@ -47,13 +47,6 @@ std::string Repo2Engine(const std::string& r) {
   }
   return r;
 };
-
-std::string GetEnginePath(std::string_view e) {
-  if (e == kLlamaRepo) {
-    return kLlamaLibPath;
-  }
-  return kLlamaLibPath;
-};
 }  // namespace
 
 cpp::result<void, std::string> EngineService::InstallEngineAsync(
@@ -238,11 +231,10 @@ cpp::result<void, std::string> EngineService::DownloadEngine(
                                        : normalized_version;
     std::unordered_set<std::string> merged_variant_name = {
         "llama-" + latest_version_semantic + "-bin-" + variant_name.value() +
-            ".tar.gz",
+            ".tar.gz",  // menlo
         "llama-" + latest_version_semantic + "-bin-" + variant_name.value() +
-            ".zip"};
+            ".zip"};  // ggml
 
-    // CTL_INF("merged_variant_name: " << merged_variant_name);
     for (const auto& asset : res.value()) {
       if (merged_variant_name.find(asset.name) != merged_variant_name.end()) {
         selected_variant = asset;
@@ -279,36 +271,35 @@ cpp::result<void, std::string> EngineService::DownloadEngine(
     }
   }
 
-  // auto normalize_version = "v" + selected_variant->version;
-  auto normalize_version = selected_variant->version;
   auto variant_folder_name = engine_matcher_utils::GetVariantFromNameAndVersion(
       selected_variant->name, engine, selected_variant->version);
   auto variant_folder_path = file_manager_utils::GetEnginesContainerPath() /
                              engine / variant_folder_name.value() /
-                             normalize_version;
+                             selected_variant->version;
   auto variant_path = variant_folder_path / selected_variant->name;
 
   std::filesystem::create_directories(variant_folder_path);
 
   CTL_INF("variant_folder_path: " + variant_folder_path.string());
-  auto on_finished = [this, engine, selected_variant, variant_folder_path,
-                      normalize_version](const DownloadTask& finishedTask) {
+  auto on_finished = [this, engine, selected_variant,
+                      variant_folder_path](const DownloadTask& finishedTask) {
     // try to unzip the downloaded file
     CTL_INF("Engine zip path: " << finishedTask.items[0].localPath.string());
-    CTL_INF("Version: " + normalize_version);
+    CTL_INF("Version: " + selected_variant->version);
 
     auto extract_path = finishedTask.items[0].localPath.parent_path();
     archive_utils::ExtractArchive(finishedTask.items[0].localPath.string(),
                                   extract_path.string(), true);
     CTL_INF("local path: " << finishedTask.items[0].localPath.string()
                            << ", extract path: " << extract_path.string());
     auto variant = engine_matcher_utils::GetVariantFromNameAndVersion(
-        selected_variant->name, engine, normalize_version);
+        selected_variant->name, engine, selected_variant->version);
     CTL_INF("Extracted variant: " + variant.value());
     try {
+      // Create version file
       std::ofstream meta(extract_path / "version.txt", std::ios::out);
       meta << "name: " << variant.value() << std::endl;
-      meta << "version: " << normalize_version << std::endl;
+      meta << "version: " << selected_variant->version << std::endl;
       meta.close();
       namespace fs = std::filesystem;
 
@@ -326,7 +317,7 @@ cpp::result<void, std::string> EngineService::DownloadEngine(
       if (!fs::exists(extract_path.parent_path().parent_path() / "deps")) {
         fs::create_directory(extract_path.parent_path().parent_path() / "deps");
       }
-      std::filesystem::permissions(extract_path / "llama-server",
+      std::filesystem::permissions(extract_path / kLlamaServer,
                                    std::filesystem::perms::owner_exec |
                                        std::filesystem::perms::group_exec |
                                        std::filesystem::perms::others_exec,
@@ -337,17 +328,17 @@ cpp::result<void, std::string> EngineService::DownloadEngine(
     }
 
     // set as default
-
-    auto res =
-        SetDefaultEngineVariant(engine, normalize_version, variant.value());
+    auto res = SetDefaultEngineVariant(engine, selected_variant->version,
+                                       variant.value());
     if (res.has_error()) {
       CTL_ERR("Failed to set default engine variant: " << res.error());
     } else {
       CTL_INF("Set default engine variant: " << res.value().variant);
     }
-    auto create_res = EngineService::UpsertEngine(
-        engine,  // engine_name
-        kLocal, "", "", normalize_version, variant.value(), "Default", "");
+    auto create_res =
+        EngineService::UpsertEngine(engine,  // engine_name
+                                    kLocal, "", "", selected_variant->version,
+                                    variant.value(), "Default", "");
 
     if (create_res.has_error()) {
       CTL_ERR("Failed to create engine entry: " << create_res->engine_name);
@@ -358,7 +349,7 @@ cpp::result<void, std::string> EngineService::DownloadEngine(
     for (const auto& entry : std::filesystem::directory_iterator(
              variant_folder_path.parent_path())) {
       if (entry.is_directory() &&
-          entry.path().filename() != normalize_version) {
+          entry.path().filename() != selected_variant->version) {
         try {
           std::filesystem::remove_all(entry.path());
         } catch (const std::exception& e) {
@@ -472,8 +463,8 @@ std::string EngineService::GetMatchedVariant(
 cpp::result<std::vector<EngineService::EngineRelease>, std::string>
 EngineService::GetEngineReleases(const std::string& engine) const {
   auto ne = cortex::engine::NormalizeEngine(engine);
-  auto ggml_org = github_release_utils::GetReleases("ggml-org", ne);
-  auto menlo = github_release_utils::GetReleases("menloresearch", ne);
+  auto ggml_org = github_release_utils::GetReleases(kGgmlOrg, ne);
+  auto menlo = github_release_utils::GetReleases(kMenloOrg, ne);
   if (ggml_org.has_error() && menlo.has_error()) {
     return cpp::fail(ggml_org.error());
   }
@@ -500,13 +491,13 @@ EngineService::GetEngineVariants(const std::string& engine,
                                  bool filter_compatible_only) const {
   auto ne = cortex::engine::NormalizeEngine(engine);
   auto engine_release_menlo =
-      github_release_utils::GetReleaseByVersion("menloresearch", ne, version);
+      github_release_utils::GetReleaseByVersion(kMenloOrg, ne, version);
   auto engine_release_ggml =
-      github_release_utils::GetReleaseByVersion("ggml-org", ne, version);
+      github_release_utils::GetReleaseByVersion(kGgmlOrg, ne, version);
 
   if (engine_release_menlo.has_error() && engine_release_ggml.has_error()) {
     return cpp::fail("Failed to get engine release: " +
-      engine_release_menlo.error());
+                     engine_release_menlo.error());
   }
   if (engine_release_menlo.has_error()) {
     CTL_WRN("Failed to get engine release: " << engine_release_menlo.error());
@@ -835,8 +826,8 @@ EngineService::GetEngineDirPath(const std::string& engine_name) {
   CTL_DBG("user defined engine path: " << user_defined_engine_path);
   const std::filesystem::path engine_dir_path = [&] {
     if (user_defined_engine_path != nullptr) {
-      return std::filesystem::path(user_defined_engine_path) /
-             GetEnginePath(ne) / selected_engine_variant->variant /
+      return std::filesystem::path(user_defined_engine_path) / kLlamaLibPath /
+             selected_engine_variant->variant /
              selected_engine_variant->version;
     } else {
       return file_manager_utils::GetEnginesContainerPath() / ne /
@@ -897,8 +888,7 @@ std::vector<EngineV> EngineService::GetLoadedEngines() {
 cpp::result<github_release_utils::GitHubRelease, std::string>
 EngineService::GetLatestEngineVersion(const std::string& engine) const {
   auto ne = cortex::engine::NormalizeEngine(engine);
-  auto res =
-      github_release_utils::GetReleaseByVersion("menloresearch", ne, "latest");
+  auto res = github_release_utils::GetReleaseByVersion(kMenloOrg, ne, "latest");
   if (res.has_error()) {
     return cpp::fail("Failed to fetch engine " + engine + " latest version!");
   }

engine/test/components/test_github_release_utils.cc

@@ -6,14 +6,14 @@ class GitHubReleaseUtilsTest : public ::testing::Test {};
 TEST_F(GitHubReleaseUtilsTest, AbleToGetReleaseByVersion) {
   auto version{"v0.1.36"};
   auto result = github_release_utils::GetReleaseByVersion(
-      "menloresearch", "cortex.llamacpp", version);
+      kMenloOrg, "cortex.llamacpp", version);
 
   ASSERT_TRUE(result.has_value());
   ASSERT_EQ(result->tag_name, version);
 }
 
 TEST_F(GitHubReleaseUtilsTest, AbleToGetReleaseList) {
-  auto result = github_release_utils::GetReleases("menloresearch", "cortex.llamacpp");
+  auto result = github_release_utils::GetReleases(kMenloOrg, "cortex.llamacpp");
 
   ASSERT_TRUE(result.has_value());
   ASSERT_TRUE(result->size() > 0);

engine/test/components/test_string_utils.cc

@@ -288,4 +288,44 @@ TEST_F(StringUtilsTestSuite, LargeInputPerformance) {
   EXPECT_EQ(RemoveSubstring(large_input, to_remove), "");
 }
 
+TEST(LTrimTest, EmptyString) {
+  std::string s = "";
+  LTrim(s);
+  EXPECT_EQ(s, "");
+}
+
+TEST(LTrimTest, NoSpaces) {
+  std::string s = "HelloWorld";
+  LTrim(s);
+  EXPECT_EQ(s, "HelloWorld");
+}
+
+TEST(LTrimTest, LeadingSpaces) {
+  std::string s = "   HelloWorld";
+  LTrim(s);
+  EXPECT_EQ(s, "HelloWorld");
+}
 
+TEST(LTrimTest, LeadingTabs) {
+  std::string s = "\t\tHelloWorld";
+  LTrim(s);
+  EXPECT_EQ(s, "HelloWorld");
+}
+
+TEST(LTrimTest, LeadingNewlines) {
+  std::string s = "\n\nHelloWorld";
+  LTrim(s);
+  EXPECT_EQ(s, "HelloWorld");
+}
+
+TEST(LTrimTest, OnlySpaces) {
+  std::string s = "   ";
+  LTrim(s);
+  EXPECT_EQ(s, "");
+}
+
+TEST(LTrimTest, MixedSpaces) {
+  std::string s = "   \t\nHelloWorld   ";
+  LTrim(s);
+  EXPECT_EQ(s, "HelloWorld   ");
+}

engine/utils/engine_constants.h

@@ -5,9 +5,12 @@ constexpr const auto kLlamaEngine = "llama-cpp";
 constexpr const auto kRemote = "remote";
 constexpr const auto kLocal = "local";
 
-
 constexpr const auto kLlamaRepo = "llama.cpp";
-constexpr const auto kLlamaLibPath = "./engines/cortex.llamacpp";
+constexpr const auto kLlamaLibPath = "./engines/llama.cpp";
+constexpr const auto kLlamaServer = "llama-server";
+
+constexpr const auto kMenloOrg = "menloresearch";
+constexpr const auto kGgmlOrg = "ggml-org";
 
 // other constants
 constexpr auto static kHuggingFaceHost = "huggingface.co";
@@ -18,6 +21,7 @@ constexpr auto static kDefaultGHUserAgent = "cortexcpp";
 constexpr auto static kWindowsOs = "win";
 constexpr auto static kMacOs = "mac";
 constexpr auto static kLinuxOs = "linux";
+constexpr auto static kUbuntuOs = "ubuntu";
 constexpr auto static kUnsupportedOs = "Unsupported OS";
 
 constexpr auto static kCurlGetTimeout = 10;