manager.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/prompts/manager.h>
#include <entropic/types/logging.h>
#include "yaml_util.h"
 
#include <ryml.hpp>
#include <c4/std/string.hpp>
 
static auto s_log = entropic::log::get("prompts");
 
// Pull yaml_util helpers into this TU to avoid qualifying every call.
using entropic::config::extract;
using entropic::config::extract_string_list;
using entropic::config::extract_string_list_opt;
using entropic::config::read_file;
using entropic::config::to_string;
 
namespace entropic::prompts {
 
static std::string trim(const std::string& s)
{
    auto start = s.find_first_not_of(" \t\n\r");
    if (start == std::string::npos) {
        return "";
    }
    auto end = s.find_last_not_of(" \t\n\r");
    return s.substr(start, end - start + 1);
}
 
static std::string parse_frontmatter(
    const std::string& content,
    const std::filesystem::path& path,
    ryml::Tree& tree,
    std::string& body)
{
    if (content.substr(0, 3) != "---") {
        return "prompt file " + path.string()
               + " missing YAML frontmatter";
    }
 
    auto second_delim = content.find("---", 3);
    if (second_delim == std::string::npos) {
        return "prompt file " + path.string()
               + " has malformed frontmatter";
    }
 
    std::string yaml_block = content.substr(3, second_delim - 3);
    body = trim(content.substr(second_delim + 3));
 
    tree = ryml::parse_in_arena(
        ryml::to_csubstr(path.string()),
        ryml::to_csubstr(yaml_block));
 
    return "";
}
 
const char* prompt_type_to_string(PromptType type)
{
    static constexpr const char* names[] = {"constitution", "app_context", "identity"};
    int idx = static_cast<int>(type);
    return (idx >= 0 && idx <= 2) ? names[idx] : "unknown";
}
 
static PromptType prompt_type_from_string(
    const std::string& type_str, const std::filesystem::path& path,
    std::string& err) {
    PromptType t{};
    if (type_str == "constitution") {
        t = PromptType::CONSTITUTION;
    } else if (type_str == "app_context") {
        t = PromptType::APP_CONTEXT;
    } else if (type_str == "identity") {
        t = PromptType::IDENTITY;
    } else {
        err = "prompt file " + path.string()
              + " has unknown type '" + type_str + "'";
    }
    return t;
}
 
std::string parse_prompt_file(
    const std::filesystem::path& path,
    PromptType expected_type,
    ParsedPrompt& result)
{
    std::string err;
 
    auto content = read_file(path);
    if (content.empty()) {
        err = "cannot read prompt file: " + path.string();
    }
 
    ryml::Tree tree;
    if (err.empty()) {
        err = parse_frontmatter(content, path, tree, result.body);
    }
 
    ryml::ConstNodeRef root;
    std::string type_str;
    if (err.empty()) {
        root = tree.rootref();
        if (!extract(root, "type", type_str)) {
            err = "prompt file " + path.string()
                  + " missing 'type' field";
        }
    }
 
    PromptType actual_type{};
    if (err.empty()) {
        actual_type = prompt_type_from_string(type_str, path, err);
    }
 
    if (err.empty() && actual_type != expected_type) {
        err = "prompt file " + path.string() + " has type '"
              + type_str + "' but was loaded as '"
              + prompt_type_to_string(expected_type) + "'";
    }
 
    if (err.empty()) {
        result.type = actual_type;
        extract(root, "version", result.version);
    }
 
    return err;
}
 
static void extract_phases(
    ryml::ConstNodeRef root, IdentityFrontmatter& fm)
{
    if (!root.has_child("phases") || !root["phases"].is_map()) {
        return;
    }
    fm.phases.emplace();
    for (auto child : root["phases"]) {
        PhaseConfig phase;
        std::string phase_name = to_string(child.key());
        extract(child, "temperature", phase.temperature);
        extract(child, "max_output_tokens", phase.max_output_tokens);
        extract(child, "enable_thinking", phase.enable_thinking);
        extract(child, "repeat_penalty", phase.repeat_penalty);
        extract_string_list_opt(child, "bash_commands", phase.bash_commands);
        (*fm.phases)[phase_name] = std::move(phase);
    }
}
 
static void extract_benchmark(
    ryml::ConstNodeRef root, IdentityFrontmatter& fm)
{
    if (!root.has_child("benchmark") || !root["benchmark"].is_map()) {
        return;
    }
    fm.benchmark.emplace();
    auto bench = root["benchmark"];
    if (!bench.has_child("prompts") || !bench["prompts"].is_seq()) {
        return;
    }
    for (auto p_node : bench["prompts"]) {
        BenchmarkPrompt bp;
        extract(p_node, "prompt", bp.prompt);
        if (p_node.has_child("checks") && p_node["checks"].is_seq()) {
            for (auto c_node : p_node["checks"]) {
                std::string check_yaml;
                ryml::emitrs_yaml(c_node, &check_yaml);
                bp.checks_yaml.push_back(std::move(check_yaml));
            }
        }
        fm.benchmark->prompts.push_back(std::move(bp));
    }
}
 
static void extract_sampler_knobs(ryml::ConstNodeRef root,
                                  IdentityFrontmatter& fm) {
    int ival = 0;
    if (extract(root, "max_output_tokens", ival)) { fm.max_output_tokens = ival; }
    if (extract(root, "top_k", ival)) { fm.top_k = ival; }
    float fval = 0.0f;
    if (extract(root, "temperature", fval)) { fm.temperature = fval; }
    if (extract(root, "top_p", fval)) { fm.top_p = fval; }
    if (extract(root, "min_p", fval)) { fm.min_p = fval; }
    if (extract(root, "presence_penalty", fval)) { fm.presence_penalty = fval; }
    if (extract(root, "frequency_penalty", fval)) { fm.frequency_penalty = fval; }
    if (extract(root, "repeat_penalty", fval)) { fm.repeat_penalty = fval; }
    // enable_thinking's GenerationParams default is true, so "not set"
    // must stay distinct from an explicit false (gh#86).
    bool think = false;
    if (extract(root, "enable_thinking", think)) { fm.enable_thinking = think; }
}
 
static void extract_identity_flags(ryml::ConstNodeRef root,
                                   IdentityFrontmatter& fm) {
    extract_sampler_knobs(root, fm);  // gh#82/gh#85/gh#86
    extract(root, "interstitial", fm.interstitial);
    extract(root, "routable", fm.routable);
    bool ec_val{};
    if (extract(root, "explicit_completion", ec_val)) {
        fm.explicit_completion = ec_val;
    }
    extract(root, "relay_single_delegate", fm.relay_single_delegate);
    // E6 (2.0.6-rc18): per-identity loop + tool-call caps
    extract(root, "max_iterations", fm.max_iterations);
    extract(root, "max_tool_calls_per_turn", fm.max_tool_calls_per_turn);
    extract(root, "max_consecutive_empty_turns", fm.max_consecutive_empty_turns);
    extract_string_list(root, "validation_rules", fm.validation_rules);
}
 
static void extract_identity_fields(
    ryml::ConstNodeRef root, IdentityFrontmatter& fm)
{
    fm.type = PromptType::IDENTITY;
    extract(root, "version", fm.version);
    extract(root, "name", fm.name);
    extract_string_list(root, "focus", fm.focus);
    extract_string_list(root, "examples", fm.examples);
 
    std::string grammar_str;
    if (extract(root, "grammar", grammar_str)) {
        fm.grammar = grammar_str;
    }
    std::string auto_chain_str;
    if (extract(root, "auto_chain", auto_chain_str)) {
        fm.auto_chain = auto_chain_str;
    }
 
    extract_string_list_opt(root, "allowed_tools", fm.allowed_tools);
    extract_string_list_opt(root, "bash_commands", fm.bash_commands);
 
    extract_identity_flags(root, fm);
 
    extract_phases(root, fm);
    extract_benchmark(root, fm);
}
 
std::string load_identity(
    const std::filesystem::path& path,
    ParsedIdentity& identity)
{
    std::string err;
 
    auto content = read_file(path);
    if (content.empty()) {
        err = "cannot read identity file: " + path.string();
    }
 
    ryml::Tree tree;
    if (err.empty()) {
        err = parse_frontmatter(content, path, tree, identity.body);
    }
 
    ryml::ConstNodeRef root;
    if (err.empty()) {
        root = tree.rootref();
 
        // Validate type field
        std::string type_str;
        if (!extract(root, "type", type_str) || type_str != "identity") {
            err = "prompt file " + path.string()
                  + " is not an identity file (type='"
                  + type_str + "')";
        }
    }
 
    if (err.empty()) {
        extract_identity_fields(root, identity.frontmatter);
 
        if (identity.frontmatter.focus.empty()) {
            err = "identity " + path.string()
                  + ": focus must have at least one entry";
        } else if (identity.frontmatter.name.empty()) {
            err = "identity " + path.string()
                  + ": name must not be empty";
        }
    }
 
    return err;
}
 
std::string load_constitution(
    const std::optional<std::filesystem::path>& constitution_path,
    bool disabled,
    const std::filesystem::path& data_dir,
    std::string& body)
{
    std::string err;
 
    if (disabled) {
        s_log->info("Constitution disabled by config");
        body.clear();
    } else {
        std::filesystem::path path = constitution_path.has_value()
            ? *constitution_path
            : data_dir / "prompts" / "constitution.md";
 
        if (!std::filesystem::exists(path)) {
            err = "constitution file not found: " + path.string();
        }
 
        ParsedPrompt result;
        if (err.empty()) {
            err = parse_prompt_file(path, PromptType::CONSTITUTION, result);
        }
 
        if (err.empty()) {
            body = std::move(result.body);
            s_log->info("Constitution loaded from {}", path.string());
        } else {
            // gh#163: report the failure where the state is known. Every
            // caller used to drop this string, so a rejected constitution
            // was indistinguishable from one that was never configured.
            body.clear();
            s_log->warn("Constitution not loaded: {}", err);
        }
    }
 
    return err;
}
 
static std::string load_app_context_file(
    const std::filesystem::path& app_context_path,
    const std::filesystem::path& data_dir,
    std::string& body)
{
    auto path = app_context_path;
 
    // Bare filename resolves as bundled prompt
    if (!path.has_parent_path() || path.parent_path().empty()) {
        path = data_dir / "prompts" / path;
    }
 
    std::string err;
    if (!std::filesystem::exists(path)) {
        err = "app_context file not found: " + path.string();
    }
 
    ParsedPrompt result;
    if (err.empty()) {
        err = parse_prompt_file(path, PromptType::APP_CONTEXT, result);
    }
 
    if (err.empty()) {
        body = std::move(result.body);
        s_log->info("App context loaded from {}", path.string());
    }
 
    return err;
}
 
AppContextState classify_app_context(
    const std::optional<std::filesystem::path>& app_context_path,
    const std::optional<std::string>& app_context_content,
    bool disabled)
{
    // gh#141: inline content wins over a path, but NOT over an explicit
    // opt-out — `app_context: false` still means off, whatever else is set.
    AppContextState state = AppContextState::NOT_CONFIGURED;
    if (disabled) {
        state = AppContextState::DISABLED;
    } else if (app_context_content.has_value()) {
        state = AppContextState::INLINE;
    } else if (app_context_path.has_value()) {
        state = AppContextState::FROM_PATH;
    }
    return state;
}
 
const char* app_context_state_message(AppContextState state)
{
    // gh#163: three of these four states used to share one line,
    // "App context disabled (not configured)" — which told a consumer
    // whose path had been REJECTED that they had never configured one.
    const char* msg = "App context not configured (no `app_context` key)";
    if (state == AppContextState::DISABLED) {
        msg = "App context explicitly disabled (`app_context: false`)";
    } else if (state == AppContextState::INLINE) {
        msg = "App context supplied inline (`app_context: {content: ...}`)";
    } else if (state == AppContextState::FROM_PATH) {
        msg = "App context configured but rejected";
    }
    return msg;
}
 
std::string load_app_context(
    const std::optional<std::filesystem::path>& app_context_path,
    const std::optional<std::string>& app_context_content,
    bool disabled,
    const std::filesystem::path& data_dir,
    std::string& body)
{
    std::string err;
    const auto state = classify_app_context(
        app_context_path, app_context_content, disabled);
 
    if (state == AppContextState::INLINE) {
        body = *app_context_content;
        s_log->info("{} — {} bytes",
                    app_context_state_message(state), body.size());
    } else if (state == AppContextState::FROM_PATH) {
        err = load_app_context_file(*app_context_path, data_dir, body);
        if (!err.empty()) {
            // The path was named and could not be used. Say so — this is
            // the state the reporter was in, described as "not configured".
            body.clear();
            s_log->warn("{}: {}", app_context_state_message(state), err);
        }
    } else {
        body.clear();
        s_log->info("{}", app_context_state_message(state));
    }
 
    return err;
}
 
void load_shared_prompt_sources(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir,
    std::string& constitution,
    std::string& app_context)
{
    // gh#156: these two return values were dropped at all three call
    // sites. A working load announced itself ("App context loaded
    // from ..."), a failing one said nothing — the asymmetry WAS the
    // bug, and it cost a consumer twenty minutes.
    //
    // gh#163: the report now lives inside each loader, which is the only
    // layer that knows WHICH state produced no body. Collapsing the two
    // calls here still matters — it is one call site to keep honest
    // instead of three.
    load_constitution(config.constitution, config.constitution_disabled,
                      data_dir, constitution);
    load_app_context(config.app_context, config.app_context_content,
                     config.app_context_disabled, data_dir, app_context);
}
 
static std::string check_constitution_source(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir)
{
    std::string err;
    if (config.constitution.has_value() && !config.constitution_disabled) {
        std::string body;
        err = load_constitution(config.constitution, false, data_dir, body);
        if (!err.empty()) {
            err = "constitution: " + err
                + ". A constitution file is one of entropic's own prompt "
                  "documents: it needs YAML frontmatter with "
                  "`type: constitution` between `---` lines.";
        }
    }
    return err;
}
 
static std::string check_app_context_source(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir)
{
    const bool configured_as_path = config.app_context.has_value()
        && !config.app_context_disabled
        && !config.app_context_content.has_value();
    std::string err;
    if (configured_as_path) {
        std::string body;
        err = load_app_context(config.app_context, std::nullopt, false,
                               data_dir, body);
        if (!err.empty()) {
            err = "app_context: " + err
                + ". app_context is read as one of entropic's own prompt "
                  "documents, so the file needs YAML frontmatter with "
                  "`type: app_context` between `---` lines. To supply a "
                  "document you do not own — a repository's CLAUDE.md, for "
                  "example — pass the text inline instead of a path: "
                  "`app_context: {content: \"...\"}` (gh#141).";
        }
    }
    return err;
}
 
std::string validate_configured_prompts(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir)
{
    std::string err = check_constitution_source(config, data_dir);
    if (err.empty()) {
        err = check_app_context_source(config, data_dir);
    }
    return err;
}
 
ParsedIdentity resolve_tier_identity_full(
    const entropic::TierConfig& tier_config,
    const std::string& tier_name,
    const std::filesystem::path& data_dir)
{
    std::filesystem::path id_path;
    if (tier_config.identity.has_value()) {
        id_path = tier_config.identity.value();
    } else if (!tier_config.identity_disabled) {
        id_path = data_dir / "prompts"
            / ("identity_" + tier_name + ".md");
    }
    ParsedIdentity id;
    if (id_path.empty() || !std::filesystem::exists(id_path)) {
        return id;
    }
    auto err = load_identity(id_path, id);
    if (!err.empty()) {
        s_log->warn("identity load failed for tier '{}': {}",
                     tier_name, err);
        return ParsedIdentity{};
    }
    s_log->info("identity loaded for tier '{}' from {}",
                 tier_name, id_path.string());
    return id;
}
 
std::string resolve_tier_identity(
    const entropic::TierConfig& tier_config,
    const std::string& tier_name,
    const std::filesystem::path& data_dir)
{
    return resolve_tier_identity_full(
        tier_config, tier_name, data_dir).body;
}
 
std::string assemble(
    const entropic::ParsedConfig& config,
    const std::filesystem::path& data_dir) {
    std::string constitution, app_ctx;
 
    load_shared_prompt_sources(config, data_dir, constitution, app_ctx);
 
    std::string identity_body;
    auto tier_it = config.models.tiers.find(config.models.default_tier);
    if (tier_it != config.models.tiers.end()) {
        identity_body = resolve_tier_identity(
            tier_it->second, config.models.default_tier, data_dir);
    }
 
    std::string prompt;
    if (!constitution.empty()) { prompt += constitution + "\n\n"; }
    if (!app_ctx.empty()) { prompt += app_ctx + "\n\n"; }
    if (!identity_body.empty()) { prompt += identity_body; }
 
    s_log->info("system prompt assembled: {} chars "
                "(constitution={}, app_context={}, identity={})",
                prompt.size(), !constitution.empty(),
                !app_ctx.empty(), !identity_body.empty());
    return prompt;
}
 
} // namespace entropic::prompts