Step 599: add incident response runbook engine

editor/src/IncidentResponseRunbookEngine.h

@@ -0,0 +1,106 @@
+#pragma once
+// Step 599: Incident Response Runbook Engine
+
+#include <map>
+#include <string>
+#include <vector>
+
+struct RunbookStep {
+    std::string stepId;
+    std::string instruction;
+    bool required = true;
+};
+
+struct Runbook {
+    std::string runbookId;
+    std::string incidentType;
+    std::vector<RunbookStep> steps;
+};
+
+struct RunbookExecutionState {
+    std::string runbookId;
+    std::vector<std::string> completedStepIds;
+    bool closed = false;
+};
+
+class IncidentResponseRunbookEngine {
+public:
+    bool registerRunbook(const Runbook& runbook, std::string* error) {
+        if (!error) return false;
+        error->clear();
+        if (runbook.runbookId.empty()) return fail(error, "runbook_id_missing");
+        if (runbook.incidentType.empty()) return fail(error, "incident_type_missing");
+        if (runbook.steps.empty()) return fail(error, "runbook_steps_missing");
+        if (runbooks_.count(runbook.runbookId) != 0) return fail(error, "runbook_duplicate");
+        runbooks_[runbook.runbookId] = runbook;
+        return true;
+    }
+
+    bool start(const std::string& runbookId, RunbookExecutionState* state, std::string* error) const {
+        if (!state || !error) return false;
+        error->clear();
+        if (runbooks_.count(runbookId) == 0) return fail(error, "runbook_missing");
+        state->runbookId = runbookId;
+        state->completedStepIds.clear();
+        state->closed = false;
+        return true;
+    }
+
+    bool completeStep(RunbookExecutionState* state,
+                      const std::string& stepId,
+                      std::string* error) const {
+        if (!state || !error) return false;
+        error->clear();
+        const auto* rb = findRunbook(state->runbookId);
+        if (!rb) return fail(error, "runbook_missing");
+        if (state->closed) return fail(error, "execution_closed");
+        if (!hasStep(*rb, stepId)) return fail(error, "step_missing");
+        for (const auto& s : state->completedStepIds) if (s == stepId) return fail(error, "step_already_completed");
+        state->completedStepIds.push_back(stepId);
+        return true;
+    }
+
+    bool closeIfReady(RunbookExecutionState* state, std::string* error) const {
+        if (!state || !error) return false;
+        error->clear();
+        const auto* rb = findRunbook(state->runbookId);
+        if (!rb) return fail(error, "runbook_missing");
+        for (const auto& step : rb->steps) {
+            if (!step.required) continue;
+            if (!isCompleted(*state, step.stepId)) return fail(error, "required_steps_incomplete");
+        }
+        state->closed = true;
+        return true;
+    }
+
+    int completionPercent(const RunbookExecutionState& state) const {
+        const auto* rb = findRunbook(state.runbookId);
+        if (!rb || rb->steps.empty()) return 0;
+        const int done = static_cast<int>(state.completedStepIds.size());
+        return (done * 100) / static_cast<int>(rb->steps.size());
+    }
+
+private:
+    std::map<std::string, Runbook> runbooks_;
+
+    static bool fail(std::string* error, const char* code) {
+        *error = code;
+        return false;
+    }
+
+    const Runbook* findRunbook(const std::string& runbookId) const {
+        auto it = runbooks_.find(runbookId);
+        if (it == runbooks_.end()) return nullptr;
+        return &it->second;
+    }
+
+    static bool hasStep(const Runbook& runbook, const std::string& stepId) {
+        for (const auto& s : runbook.steps) if (s.stepId == stepId) return true;
+        return false;
+    }
+
+    static bool isCompleted(const RunbookExecutionState& state, const std::string& stepId) {
+        for (const auto& s : state.completedStepIds) if (s == stepId) return true;
+        return false;
+    }
+};