directives.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/types/enums.h>
#include <entropic/types/message.h>
#include <entropic/interfaces/i_hook_handler.h>
 
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic {
 
struct LoopContext; // forward declaration
 
// ── Directive structs ────────────────────────────────────
 
struct Directive {
    entropic_directive_type_t type; 
};
 
struct StopProcessingDirective : Directive {
    StopProcessingDirective() {
        type = ENTROPIC_DIRECTIVE_STOP_PROCESSING;
    }
};
 
struct TierChangeDirective : Directive {
    std::string tier;   
    std::string reason; 
 
    TierChangeDirective(std::string t = "", std::string r = "")
        : tier(std::move(t)), reason(std::move(r)) {
        type = ENTROPIC_DIRECTIVE_TIER_CHANGE;
    }
};
 
struct ContextRef {
    std::string path;   
    std::string lines;  
    std::string note;   
};
 
struct DelegateDirective : Directive {
    std::string target;                   
    std::string task;                     
    int max_turns = -1;                   
    std::string resume_from_delegation_id; 
    std::vector<ContextRef> context;      
    bool resume_by_target = false;
 
    DelegateDirective(std::string tgt = "",
                      std::string tsk = "",
                      int mt = -1,
                      std::string resume_id = "")
        : target(std::move(tgt)),
          task(std::move(tsk)),
          max_turns(mt),
          resume_from_delegation_id(std::move(resume_id)) {
        type = ENTROPIC_DIRECTIVE_DELEGATE;
    }
};
 
struct PipelineDirective : Directive {
    std::vector<std::string> stages; 
    std::string task;                
    std::vector<ContextRef> context; 
 
    PipelineDirective(std::vector<std::string> s = {},
                      std::string t = "")
        : stages(std::move(s)), task(std::move(t)) {
        type = ENTROPIC_DIRECTIVE_PIPELINE;
    }
};
 
struct CompleteDirective : Directive {
    std::string summary; 
    bool coverage_gap = false; 
    std::string gap_description; 
    std::vector<std::string> suggested_files; 
 
    explicit CompleteDirective(std::string s = "")
        : summary(std::move(s)) {
        type = ENTROPIC_DIRECTIVE_COMPLETE;
    }
};
 
struct ClearSelfTodosDirective : Directive {
    ClearSelfTodosDirective() {
        type = ENTROPIC_DIRECTIVE_CLEAR_SELF_TODOS;
    }
};
 
struct InjectContextDirective : Directive {
    std::string content; 
    std::string role = "user"; 
 
    InjectContextDirective(std::string c = "",
                           std::string r = "user")
        : content(std::move(c)), role(std::move(r)) {
        type = ENTROPIC_DIRECTIVE_INJECT_CONTEXT;
    }
};
 
struct PruneMessagesDirective : Directive {
    int keep_recent = 2; 
 
    explicit PruneMessagesDirective(int k = 2)
        : keep_recent(k) {
        type = ENTROPIC_DIRECTIVE_PRUNE_MESSAGES;
    }
};
 
struct ContextAnchorDirective : Directive {
    std::string key;     
    std::string content; 
 
    ContextAnchorDirective(std::string k = "",
                           std::string c = "")
        : key(std::move(k)), content(std::move(c)) {
        type = ENTROPIC_DIRECTIVE_CONTEXT_ANCHOR;
    }
};
 
struct PhaseChangeDirective : Directive {
    std::string phase; 
 
    explicit PhaseChangeDirective(std::string p = "")
        : phase(std::move(p)) {
        type = ENTROPIC_DIRECTIVE_PHASE_CHANGE;
    }
};
 
struct NotifyPresenterDirective : Directive {
    std::string key;       
    std::string data_json; 
 
    NotifyPresenterDirective(std::string k = "",
                             std::string d = "")
        : key(std::move(k)), data_json(std::move(d)) {
        type = ENTROPIC_DIRECTIVE_NOTIFY_PRESENTER;
    }
};
 
// ── DirectiveResult ──────────────────────────────────────
 
struct DirectiveResult {
    bool stop_processing = false;           
    bool tier_changed = false;              
    std::vector<Message> injected_messages; 
};
 
// ── DirectiveHandler type ────────────────────────────────
 
using DirectiveHandler = std::function<void(
    LoopContext& ctx,
    const Directive& directive,
    DirectiveResult& result)>;
 
// ── DirectiveProcessor ───────────────────────────────────
 
class DirectiveProcessor {
public:
    void register_handler(entropic_directive_type_t dtype,
                          DirectiveHandler handler);
 
    DirectiveResult process(
        LoopContext& ctx,
        const std::vector<const Directive*>& directives);
 
    void set_hooks(const HookInterface& hooks) { hooks_ = hooks; }
 
private:
    bool fire_directive_hook(const Directive* directive,
                             bool has_handler);          
 
    std::unordered_map<int, DirectiveHandler> handlers_; 
    HookInterface hooks_;                                
};
 
} // namespace entropic