format

tooling/pipeline/src/services/enrichment/wikipedia/fetch_extract.cc

@@ -20,9 +20,10 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   if (const auto cache_it = this->extract_cache_.find(cache_key);
       cache_it != this->extract_cache_.end()) {
     if (logger_) {
-      logger_->Log({.level = LogLevel::Debug,
-                    .phase = PipelinePhase::Enrichment,
-                    .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
+      logger_->Log(
+          {.level = LogLevel::Debug,
+           .phase = PipelinePhase::Enrichment,
+           .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
     }
     return cache_it->second;
   }
@@ -30,7 +31,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const std::string encoded = this->client_->EncodeURL(cache_key);
   const std::string url = std::format(
       "https://en.wikipedia.org/w/"
-      "api.php?action=query&titles={}&prop=extracts&explaintext=1&format=json",
+      "api.php?action=query&titles={}&prop=extracts&explaintext=1&format="
+      "json",
       encoded);
 
   const std::string body = this->client_->Get(url);
@@ -45,11 +47,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (ec) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message = std::format("WikipediaService: JSON parse error for '{}': {}",
-                      std::string(query), ec.message())});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: JSON parse error for '{}': {}",
+                        std::string(query), ec.message())});
     }
     return {};
   }
@@ -58,12 +60,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const json::object* obj = doc.if_object();
   if (obj == nullptr) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message =
-               std::format("WikipediaService: Expected root object for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Expected root object for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -76,12 +77,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((pages_ptr == nullptr) || !pages_ptr->is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message =
-               std::format("WikipediaService: Missing query.pages for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Missing query.pages for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -90,11 +90,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (pages.empty()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message = std::format("WikipediaService: No pages returned for '{}'",
-                      std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: No pages returned for '{}'",
+                        std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -106,12 +106,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (!page_val.is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message =
-               std::format("WikipediaService: Unexpected page format for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: Unexpected page format for '{}'",
+                        std::string(query))});
     }
     return {};
   }
@@ -121,10 +120,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // Handle 404/Missing status
   if (page.contains("missing")) {
     if (logger_) {
-      logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::Enrichment,
-                    .message = std::format("WikipediaService: Page '{}' does not exist",
-                               std::string(query))});
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::Enrichment,
+           .message = std::format("WikipediaService: Page '{}' does not exist",
+                                  std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -134,12 +134,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((extract_ptr == nullptr) || !extract_ptr->is_string()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::Enrichment,
-           .message =
-               std::format("WikipediaService: No extract string found for '{}'",
-               std::string(query))});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::Enrichment,
+                    .message = std::format(
+                        "WikipediaService: No extract string found for '{}'",
+                        std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -148,10 +147,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // 4. Success
   std::string extract(extract_ptr->as_string());
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::Enrichment,
-                  .message = std::format("WikipediaService: Fetched {} chars for '{}'",
-                             extract.size(), std::string(query))});
+    logger_->Log(
+        {.level = LogLevel::Info,
+         .phase = PipelinePhase::Enrichment,
+         .message = std::format("WikipediaService: Fetched {} chars for '{}'",
+                                extract.size(), std::string(query))});
   }
 
   this->extract_cache_.insert_or_assign(cache_key, extract);

tooling/pipeline/src/services/enrichment/wikipedia/get_summary.cc

@@ -45,8 +45,9 @@ std::string WikipediaEnrichmentService::GetLocationContext(
     if (logger_) {
       logger_->Log({.level = LogLevel::Info,
                     .phase = PipelinePhase::Enrichment,
-                    .message = std::format("Done fetching for {}. Sleeping for 10 seconds.",
-                               location_query)});
+                    .message = std::format(
+                        "Done fetching for {}. Sleeping for 10 seconds.",
+                        location_query)});
     }
     std::this_thread::sleep_for(10s);
 
@@ -56,7 +57,7 @@ std::string WikipediaEnrichmentService::GetLocationContext(
           {.level = LogLevel::Debug,
            .phase = PipelinePhase::Enrichment,
            .message = std::format("WikipediaService lookup failed for '{}': {}",
-                      location_query, e.what())});
+                                  location_query, e.what())});
     }
   }
   return result;

tooling/pipeline/src/services/prompt_directory.cc

@@ -44,8 +44,8 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
   // Scenario 4: directory must be readable (probe with directory_iterator).
   std::filesystem::directory_iterator probe(prompt_dir_, ec);
   if (ec) {
-    throw std::runtime_error(
-        std::format("PromptDirectory: prompt directory is not readable: {} ({})",
+    throw std::runtime_error(std::format(
+        "PromptDirectory: prompt directory is not readable: {} ({})",
         prompt_dir_.string(), ec.message()));
   }
 
@@ -76,7 +76,7 @@ std::string PromptDirectory::Load(std::string_view key) {
   if (!file.is_open()) {
     throw std::runtime_error(
         std::format("PromptDirectory: prompt file not found for key '{}': {}",
-        key_str, file_path.string()));
+                    key_str, file_path.string()));
   }
 
   std::string content((std::istreambuf_iterator<char>(file)),
@@ -84,15 +84,18 @@ std::string PromptDirectory::Load(std::string_view key) {
   file.close();
 
   if (content.empty()) {
-    throw std::runtime_error(std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
-                             key_str, file_path.string()));
+    throw std::runtime_error(
+        std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
+                    key_str, file_path.string()));
   }
 
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::Startup,
-                  .message = std::format("[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
-                             key_str, file_path.string(), content.size())});
+    logger_->Log(
+        {.level = LogLevel::Info,
+         .phase = PipelinePhase::Startup,
+         .message = std::format(
+             "[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
+             key_str, file_path.string(), content.size())});
   }
 
   cache_.emplace(key_str, content);

tooling/pipeline/src/services/sqlite/initialize.cc

@@ -18,9 +18,9 @@ std::filesystem::path SqliteExportService::BuildDatabasePath() const {
   std::filesystem::path candidate = output_path_ / base_filename;
 
   for (int suffix = 1; std::filesystem::exists(candidate); ++suffix) {
-    candidate = output_path_ /
-                std::filesystem::path(std::format("biergarten_seed_{}-{}.sqlite",
-                                      run_timestamp_utc_, suffix));
+    candidate = output_path_ / std::filesystem::path(
+                                   std::format("biergarten_seed_{}-{}.sqlite",
+                                               run_timestamp_utc_, suffix));
   }
 
   return candidate;

tooling/pipeline/src/services/sqlite/process_record.cc

@@ -38,8 +38,7 @@ sqlite3_int64 SqliteExportService::ResolveLocationId(const Location& location) {
   }
 
   const std::string local_languages_json =
-      sqlite_export_service_internal::SerializeVector(
-          location.local_languages);
+      sqlite_export_service_internal::SerializeVector(location.local_languages);
 
   sqlite_export_service_internal::Bind(
       insert_location_stmt_,
@@ -92,7 +91,8 @@ sqlite3_int64 SqliteExportService::ResolveLocationId(const Location& location) {
           .action = "Failed to bind SQLite location longitude"});
 
   sqlite_export_service_internal::StepStatement(
-      db_handle_, insert_location_stmt_, "Failed to insert SQLite location row");
+      db_handle_, insert_location_stmt_,
+      "Failed to insert SQLite location row");
 
   const sqlite3_int64 location_id =
       sqlite_export_service_internal::LastInsertRowId(db_handle_);