ProjectSync.cppm

Go to the documentation of this file.

module;
 
#include <unistd.h>
 
#include <chrono>
#include <cstdint>
#include <ctime>
#include <filesystem>
#include <fstream>
#include <set>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
#include "json.hpp"
 
export module ProjectSync;
 
import std;
import InterfaceLog;
 
export namespace ProjectSync {
 
// ---- 公共数据契约 ---------------------------------------------------------

struct DbPaths {
  std::filesystem::path project_db{"data/Project.json"};  
  std::filesystem::path stack_db{"data/Stack.json"};      
};

enum class SyncError {
  search_path_missing,        
  search_path_not_directory,  
  project_db_unreadable,      
  project_file_unreadable,    
  io_failure,                 
};

struct SyncSummary {
  std::size_t project_count = 0;                       
  std::size_t stack_count = 0;                         
  std::vector<std::filesystem::path> library_paths;    
  std::vector<std::filesystem::path> failed_projects;  
};

std::expected<SyncSummary, SyncError> sync_all(const std::filesystem::path& search_path,
                                               const DbPaths& paths = {});

template <std::invocable<const std::filesystem::directory_entry&> Visitor>
void for_each_project_file(const std::filesystem::path& directory, Visitor&& visitor) {
  if (!std::filesystem::exists(directory) || !std::filesystem::is_directory(directory)) {
    return;
  }
 
  std::error_code error;
  std::filesystem::recursive_directory_iterator iterator(
      directory, std::filesystem::directory_options::skip_permission_denied, error);
  const std::filesystem::recursive_directory_iterator end;
  while (!error && iterator != end) {
    if (iterator->is_regular_file(error) && iterator->path().extension() == ".project") {
      std::invoke(visitor, *iterator);
    }
    iterator.increment(error);
  }
}

std::string_view sync_error_message(SyncError error) noexcept;

std::string format_file_time(std::filesystem::file_time_type file_time);
 
}  // namespace ProjectSync
 
namespace ProjectSync {
 
namespace {
 
namespace fs = std::filesystem;
using json = nlohmann::json;
 
std::string now_timestamp() {
  // Project/Stack 索引的 updateTime 使用本地秒级时间，和 Stacks 文本界面一致。
  return std::format("{:%Y-%m-%d %H:%M:%S}", std::chrono::system_clock::now());
}

fs::path normalized_path(const fs::path& value) {
  std::error_code error;
  const fs::path canonical = fs::weakly_canonical(value, error);
  if (!error) {
    return canonical;
  }
  return fs::absolute(value, error).lexically_normal();
}

std::expected<std::set<std::string>, SyncError> load_library_paths(const fs::path& project_db) {
  std::set<std::string> result;
  if (!fs::exists(project_db)) {
    return result;
  }
 
  std::ifstream input(project_db);
  try {
    json db;
    if (!(input >> db) || !db.is_object()) {
      return std::unexpected(SyncError::project_db_unreadable);
    }
    if (db.contains("library_paths") && db["library_paths"].is_array()) {
      for (const auto& item : db["library_paths"]) {
        if (item.is_string() && !item.get<std::string>().empty()) {
          result.insert(normalized_path(item.get<std::string>()).string());
        }
      }
    }
  } catch (const std::exception&) {
    return std::unexpected(SyncError::project_db_unreadable);
  }
  return result;
}

bool atomic_write_json(const fs::path& target, const json& value) {
  std::error_code error;
  if (target.has_parent_path()) {
    fs::create_directories(target.parent_path(), error);
    if (error) {
      return false;
    }
  }
 
  const fs::path temporary =
      target.parent_path() /
      std::format(".{}.tmp.{}.{}", target.filename().string(), ::getpid(),
                  std::chrono::steady_clock::now().time_since_epoch().count());
  {
    // 关闭 ofstream 后再 rename；保证目标文件看到的是完整 JSON。
    std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
    if (!output) {
      return false;
    }
    output << value.dump(4) << '\n';
    output.flush();
    if (!output) {
      fs::remove(temporary, error);
      return false;
    }
  }
 
  fs::rename(temporary, target, error);
  if (error) {
    fs::remove(temporary, error);
    return false;
  }
  return true;
}

std::string safe_string(const json& object, std::string_view key, std::string fallback = {}) {
  if (object.is_object() && object.contains(key) && object[key].is_string()) {
    return object[key].get<std::string>();
  }
  return fallback;
}
 
}  // namespace
 
std::string format_file_time(fs::file_time_type file_time) {
  // file_clock 的纪元没有跨平台保证，通过“当前时钟差值”平移到 system_clock。
  const auto system_time = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
      file_time - fs::file_time_type::clock::now() + std::chrono::system_clock::now());
  const std::time_t seconds = std::chrono::system_clock::to_time_t(system_time);
 
  // Homebrew libc++ 可能没有 tzdb；localtime_r + strftime 是当前平台的稳定回退。
  std::tm local{};
  if (localtime_r(&seconds, &local) == nullptr) {
    return {};
  }
  char buffer[32]{};
  if (std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &local) == 0) {
    return {};
  }
  return buffer;
}
 
std::expected<SyncSummary, SyncError> sync_all(const fs::path& search_path, const DbPaths& paths) {
  // 接口日志先保存业务入参，输出在 operation 完成后统一记录。
  const std::string input =
      std::format("search_path={} project_db={} stack_db={}", search_path.string(),
                  paths.project_db.string(), paths.stack_db.string());
  SyncSummary summary;
  std::optional<SyncError> first_error;
 
  // 整段同步收进立即调用 lambda：每个错误分支直接 return，避免深嵌套。
  const auto operation = [&]() -> std::expected<std::monostate, SyncError> {
    // 阶段 1：恢复历史路径，并校验/追加本次新路径。
    auto library_paths = load_library_paths(paths.project_db);
    if (!library_paths) {
      return std::unexpected(library_paths.error());
    }
    if (!search_path.empty()) {
      if (!fs::exists(search_path)) {
        return std::unexpected(SyncError::search_path_missing);
      }
      if (!fs::is_directory(search_path)) {
        return std::unexpected(SyncError::search_path_not_directory);
      }
      library_paths->insert(normalized_path(search_path).string());
    }
 
    // 阶段 2：遍历工作区，生成 Project 索引与扁平 Project/Stack 索引。
    json project_nodes = json::array();
    json stack_nodes = json::array();
    std::set<std::string> project_ids;
 
    for (const auto& library_path_string : *library_paths) {
      const fs::path library_path(library_path_string);
      if (!fs::exists(library_path) || !fs::is_directory(library_path)) {
        continue;
      }
      summary.library_paths.push_back(library_path);
 
      // 先收集后排序，消除 recursive_directory_iterator 的平台相关顺序。
      std::vector<fs::directory_entry> project_files;
      try {
        for_each_project_file(library_path, [&](const fs::directory_entry& entry) {
          project_files.push_back(entry);
        });
      } catch (const std::exception&) {
        if (!first_error) {
          first_error = SyncError::io_failure;
        }
        continue;
      }
      std::ranges::sort(project_files, {},
                        [](const auto& entry) { return entry.path().lexically_normal().string(); });
 
      for (const auto& entry : project_files) {
        try {
          // 单个项目损坏时记录路径并继续，不牺牲同一工作区的其他项目。
          std::ifstream project_file(entry.path(), std::ios::binary);
          json content;
          if (!(project_file >> content) || !content.is_object()) {
            summary.failed_projects.push_back(entry.path());
            if (!first_error) {
              first_error = SyncError::project_file_unreadable;
            }
            continue;
          }
 
          const std::string project_id = safe_string(content, "id");
          // 空 ID/重复 ID 不能进入索引，否则 Alfred action token 无法稳定寻址。
          if (project_id.empty() || !project_ids.insert(project_id).second) {
            summary.failed_projects.push_back(entry.path());
            if (!first_error) {
              first_error = SyncError::project_file_unreadable;
            }
            continue;
          }
          const std::string project_title = safe_string(content, "title", "Untitled");
          const std::string project_path = normalized_path(entry.path()).string();
          const std::string modified = format_file_time(entry.last_write_time());
 
          // 项目自身同时出现在 Project 与 Stack 索引，允许项目级直接创建任务。
          project_nodes.push_back({
              {"id", project_id},
              {"title", project_title},
              {"path", project_path},
              {"library_path", library_path.string()},
              {"mtime", modified},
          });
          stack_nodes.push_back({
              {"id", project_id},
              {"projectid", project_id},
              {"title", project_title},
              {"kind", "project"},
              {"project_path", project_path},
              {"library_path", library_path.string()},
          });
 
          if (!content.contains("stacks") || !content["stacks"].is_array()) {
            continue;
          }
          // 清单节点继承 projectid，WorkflowUI 可据此显示“项目 → 清单”三级路径。
          for (const auto& stack : content["stacks"]) {
            if (!stack.is_object()) {
              continue;
            }
            const std::string stack_id = safe_string(stack, "id");
            if (stack_id.empty()) {
              continue;
            }
            stack_nodes.push_back({
                {"id", stack_id},
                {"projectid", project_id},
                {"title", safe_string(stack, "title", "Untitled")},
                {"kind", "stack"},
                {"project_path", project_path},
                {"library_path", library_path.string()},
            });
          }
        } catch (const std::exception&) {
          summary.failed_projects.push_back(entry.path());
          if (!first_error) {
            first_error = SyncError::project_file_unreadable;
          }
        }
      }
    }
 
    summary.project_count = project_nodes.size();
    summary.stack_count = stack_nodes.size();
 
    // 阶段 3：先完整构造两个 JSON，再分别做原子替换。
    const json project_db = {
        {"library_paths", json(*library_paths)},
        {"nodes", std::move(project_nodes)},
        {"updateTime", now_timestamp()},
    };
    const json stack_db = {
        {"nodes", std::move(stack_nodes)},
        {"updateTime", now_timestamp()},
    };
    if (!atomic_write_json(paths.project_db, project_db) ||
        !atomic_write_json(paths.stack_db, stack_db)) {
      return std::unexpected(SyncError::io_failure);
    }
    // 部分项目损坏仍完成索引刷新，但调用方会收到明确的分类错误。
    if (first_error) {
      return std::unexpected(*first_error);
    }
    return {};
  }();
 
  // 所有可恢复错误都通过 expected 返回；日志记录稳定的摘要而非异常栈。
  const bool ok = operation.has_value();
  const std::string output =
      std::format("ok={} projects={} stacks={} failed_projects={} error={}", ok,
                  summary.project_count, summary.stack_count, summary.failed_projects.size(),
                  ok ? std::string{} : sync_error_message(operation.error()));
  interface_log::record(interface_log::ApiName("ProjectSync::sync_all"),
                        interface_log::LogText(input), interface_log::LogText(output),
                        ok ? interface_log::ApiStatus::ok : interface_log::ApiStatus::failed);
  if (!operation) {
    return std::unexpected(operation.error());
  }
  return summary;
}
 
std::string_view sync_error_message(SyncError error) noexcept {
  // 错误文案是 Alfred/Debug trace 的对外契约，集中在此维护。
  switch (error) {
    case SyncError::search_path_missing:
      return "search path does not exist";
    case SyncError::search_path_not_directory:
      return "search path is not a directory";
    case SyncError::project_db_unreadable:
      return "cannot parse project database";
    case SyncError::project_file_unreadable:
      return "one or more project files cannot be parsed";
    case SyncError::io_failure:
      return "failed to write database";
  }
  return "unknown sync error";
}
 
}  // namespace ProjectSync