proposal_drawer.cc

Go to the documentation of this file.

#include "app/editor/system/workspace/proposal_drawer.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <filesystem>
#include <fstream>
#include <sstream>
 
#include "absl/strings/str_format.h"
#include "absl/time/time.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/ui_helpers.h"
#include "imgui/imgui.h"
 
// Policy evaluation support (optional, only in main yaze build)
#ifdef YAZE_ENABLE_POLICY_FRAMEWORK
#include "cli/service/planning/policy_evaluator.h"
#endif
 
namespace yaze {
namespace editor {
 
ProposalDrawer::ProposalDrawer() {
  RefreshProposals();
}
 
void ProposalDrawer::DrawContent() {
  // Draw content without window wrapper (for embedding in RightDrawerManager)
  if (needs_refresh_) {
    RefreshProposals();
    needs_refresh_ = false;
    if (!selected_proposal_id_.empty() && !selected_proposal_) {
      SelectProposal(selected_proposal_id_);
    }
  }
 
  // Header with refresh button
  if (ImGui::Button(ICON_MD_REFRESH " Refresh")) {
    RefreshProposals();
  }
  ImGui::SameLine();
  DrawStatusFilter();
  if (!action_status_.ok()) {
    ImGui::PushStyleColor(ImGuiCol_Text, gui::GetErrorColor());
    ImGui::TextWrapped("%s", std::string(action_status_.message()).c_str());
    ImGui::PopStyleColor();
  } else if (!action_feedback_.empty()) {
    ImGui::TextWrapped("%s", tr(action_feedback_.c_str()));
  }
 
  ImGui::Separator();
 
  // Split view: proposal list on top, details on bottom
  const float avail_y = std::max(0.0f, ImGui::GetContentRegionAvail().y);
  const float detail_reserve =
      selected_proposal_ ? std::min(120.0f, avail_y * 0.4f) : 0.0f;
  const float list_budget = std::max(0.0f, avail_y - detail_reserve);
  const float preferred_list = std::clamp(avail_y * 0.45f, 180.0f, 320.0f);
  const float list_height = std::min(preferred_list, list_budget);
 
  ImGui::BeginChild("ProposalListEmbed", ImVec2(0, list_height), true);
  DrawProposalList();
  ImGui::EndChild();
 
  if (selected_proposal_) {
    ImGui::Separator();
    ImGui::BeginChild("ProposalDetailEmbed", ImVec2(0, 0), true);
    DrawProposalDetail();
    ImGui::EndChild();
  }
  DrawConfirmationDialog();
}
 
void ProposalDrawer::Draw() {
  if (!visible_)
    return;
 
  ImGuiIO& io = ImGui::GetIO();
  ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x - drawer_width_, 0),
                          ImGuiCond_Always);
  ImGui::SetNextWindowSize(ImVec2(drawer_width_, io.DisplaySize.y),
                           ImGuiCond_Always);
  const ImGuiWindowFlags flags = ImGuiWindowFlags_NoMove |
                                 ImGuiWindowFlags_NoResize |
                                 ImGuiWindowFlags_NoCollapse;
  if (ImGui::Begin("Agent Proposals", &visible_, flags)) {
    DrawContent();
  }
  ImGui::End();
}
 
void ProposalDrawer::SetRom(Rom* rom) {
  if (rom_ == rom)
    return;
  rom_ = rom;
  InvalidateRomContext();
}
 
void ProposalDrawer::InvalidateRomContext() {
  CancelPendingAction();
  selected_proposal_id_.clear();
  selected_proposal_ = nullptr;
  diff_content_.clear();
  log_content_.clear();
  action_status_ = absl::OkStatus();
  action_feedback_.clear();
  needs_refresh_ = true;
}
 
void ProposalDrawer::CancelPendingAction() {
  show_confirm_dialog_ = false;
  confirm_action_.clear();
  confirm_proposal_id_.clear();
}
 
void ProposalDrawer::DrawConfirmationDialog() {
  if (show_confirm_dialog_) {
    ImGui::OpenPopup("Confirm Proposal Action");
    show_confirm_dialog_ = false;
  }
  if (!ImGui::BeginPopupModal("Confirm Proposal Action", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize)) {
    return;
  }
  if (confirm_action_.empty() || confirm_proposal_id_.empty()) {
    ImGui::CloseCurrentPopup();
    ImGui::EndPopup();
    return;
  }
 
  ImGui::Text(tr("Are you sure you want to %s this proposal?"),
              confirm_action_.c_str());
  ImGui::Separator();
  if (ImGui::Button(tr("Yes"), ImVec2(120, 0))) {
    if (confirm_action_ == "reject") {
      action_status_ = RejectProposal(confirm_proposal_id_);
      action_feedback_ = "Proposal rejected.";
    } else if (confirm_action_ == "delete") {
      action_status_ = DeleteProposal(confirm_proposal_id_);
      action_feedback_ = "Proposal deleted.";
    } else {
      action_status_ = AcceptProposal(confirm_proposal_id_);
      action_feedback_.clear();
    }
    CancelPendingAction();
    ImGui::CloseCurrentPopup();
    RefreshProposals();
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("No"), ImVec2(120, 0))) {
    CancelPendingAction();
    ImGui::CloseCurrentPopup();
  }
  ImGui::EndPopup();
}
 
void ProposalDrawer::DrawProposalList() {
  if (proposals_.empty()) {
    ImGui::TextWrapped(tr("No proposals found."));
    ImGui::TextWrapped(tr("Run CLI command: z3ed agent run --prompt \"...\""));
    return;
  }
 
  ImGuiTableFlags flags =
      ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY;
 
  if (ImGui::BeginTable("ProposalsTable", 3, flags)) {
    ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed, 60.0f);
    ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed, 80.0f);
    ImGui::TableSetupColumn("Prompt", ImGuiTableColumnFlags_WidthStretch);
    ImGui::TableSetupScrollFreeze(0, 1);
    ImGui::TableHeadersRow();
 
    for (const auto& proposal : proposals_) {
      ImGui::TableNextRow();
 
      // ID column
      ImGui::TableSetColumnIndex(0);
      bool is_selected = (proposal.id == selected_proposal_id_);
      if (ImGui::Selectable(proposal.id.c_str(), is_selected,
                            ImGuiSelectableFlags_SpanAllColumns)) {
        SelectProposal(proposal.id);
      }
 
      // Status column
      ImGui::TableSetColumnIndex(1);
      switch (proposal.status) {
        case cli::ProposalRegistry::ProposalStatus::kPending:
          ImGui::TextColored(gui::GetWarningColor(),
                             ICON_MD_HOURGLASS_TOP " Pending");
          break;
        case cli::ProposalRegistry::ProposalStatus::kAccepted:
          ImGui::TextColored(gui::GetSuccessColor(),
                             ICON_MD_CHECK_CIRCLE " Accepted");
          break;
        case cli::ProposalRegistry::ProposalStatus::kRejected:
          ImGui::TextColored(gui::GetErrorColor(), ICON_MD_CANCEL " Rejected");
          break;
      }
 
      // Prompt column (truncated)
      ImGui::TableSetColumnIndex(2);
      std::string truncated = proposal.prompt;
      if (truncated.length() > 30) {
        truncated = truncated.substr(0, 27) + "...";
      }
      ImGui::TextWrapped("%s", truncated.c_str());
    }
 
    ImGui::EndTable();
  }
}
 
void ProposalDrawer::DrawProposalDetail() {
  if (!selected_proposal_)
    return;
 
  const auto& p = *selected_proposal_;
 
  // Metadata section
  if (ImGui::CollapsingHeader(tr("Metadata"), ImGuiTreeNodeFlags_DefaultOpen)) {
    ImGui::Text(tr("ID: %s"), p.id.c_str());
    ImGui::Text(tr("Sandbox: %s"), p.sandbox_id.c_str());
    ImGui::Text(tr("Created: %s"), absl::FormatTime(p.created_at).c_str());
    if (p.reviewed_at.has_value()) {
      ImGui::Text(tr("Reviewed: %s"), absl::FormatTime(*p.reviewed_at).c_str());
    }
    ImGui::Text(tr("Commands: %d"), p.commands_executed);
    ImGui::Text(tr("Bytes Changed: %d"), p.bytes_changed);
    ImGui::Separator();
    ImGui::TextWrapped(tr("Prompt: %s"), p.prompt.c_str());
    ImGui::TextWrapped(tr("Description: %s"), p.description.c_str());
  }
 
  // Diff section
  if (ImGui::CollapsingHeader(tr("Diff"), ImGuiTreeNodeFlags_DefaultOpen)) {
    if (diff_content_.empty() && std::filesystem::exists(p.diff_path)) {
      std::ifstream diff_file(p.diff_path);
      if (diff_file.is_open()) {
        std::stringstream buffer;
        buffer << diff_file.rdbuf();
        diff_content_ = buffer.str();
      }
    }
 
    if (!diff_content_.empty()) {
      ImGui::BeginChild("DiffContent", ImVec2(0, 150), true,
                        ImGuiWindowFlags_HorizontalScrollbar);
      ImGui::TextUnformatted(diff_content_.c_str());
      ImGui::EndChild();
    } else {
      ImGui::TextWrapped(tr("No diff available"));
    }
  }
 
  // Log section
  if (ImGui::CollapsingHeader(tr("Execution Log"))) {
    if (log_content_.empty() && std::filesystem::exists(p.log_path)) {
      std::ifstream log_file(p.log_path);
      if (log_file.is_open()) {
        std::stringstream buffer;
        std::string line;
        int line_count = 0;
        while (std::getline(log_file, line) &&
               line_count < log_display_lines_) {
          buffer << line << "\n";
          line_count++;
        }
        if (line_count >= log_display_lines_) {
          buffer << "... (truncated, see " << p.log_path.string() << ")\n";
        }
        log_content_ = buffer.str();
      }
    }
 
    if (!log_content_.empty()) {
      ImGui::BeginChild("LogContent", ImVec2(0, 150), true,
                        ImGuiWindowFlags_HorizontalScrollbar);
      ImGui::TextUnformatted(log_content_.c_str());
      ImGui::EndChild();
    } else {
      ImGui::TextWrapped(tr("No log available"));
    }
  }
 
  // Policy Status section (NEW)
#ifdef YAZE_ENABLE_POLICY_FRAMEWORK
  DrawPolicyStatus();
#endif
 
  // Action buttons
  ImGui::Separator();
  DrawActionButtons();
}
 
void ProposalDrawer::DrawStatusFilter() {
  const char* filter_labels[] = {"All", "Pending", "Accepted", "Rejected"};
  int current_filter = static_cast<int>(status_filter_);
 
  ImGui::SetNextItemWidth(120.0f);
  if (ImGui::Combo(tr("Filter"), &current_filter, filter_labels, 4)) {
    status_filter_ = static_cast<StatusFilter>(current_filter);
    RefreshProposals();
  }
}
 
void ProposalDrawer::DrawPolicyStatus() {
#ifdef YAZE_ENABLE_POLICY_FRAMEWORK
  if (!selected_proposal_)
    return;
 
  const auto& p = *selected_proposal_;
 
  // Only evaluate policies for pending proposals
  if (p.status != cli::ProposalRegistry::ProposalStatus::kPending) {
    return;
  }
 
  if (ImGui::CollapsingHeader(tr("Policy Status"),
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    auto& policy_eval = cli::PolicyEvaluator::GetInstance();
 
    if (!policy_eval.IsEnabled()) {
      ImGui::TextColored(gui::GetDisabledColor(),
                         ICON_MD_INFO " No policies configured");
      ImGui::TextWrapped(
          tr("Create .yaze/policies/agent.yaml to enable policy evaluation"));
      return;
    }
 
    // Evaluate proposal against policies
    auto policy_result = policy_eval.EvaluateProposal(p.id);
 
    if (!policy_result.ok()) {
      ImGui::TextColored(gui::GetErrorColor(),
                         ICON_MD_ERROR " Policy evaluation failed");
      ImGui::TextWrapped("%s", policy_result.status().message().data());
      return;
    }
 
    const auto& result = policy_result.value();
 
    // Overall status
    if (result.is_clean()) {
      ImGui::TextColored(gui::GetSuccessColor(),
                         ICON_MD_VERIFIED " All policies passed");
    } else if (result.passed) {
      ImGui::TextColored(gui::GetWarningColor(),
                         ICON_MD_WARNING " Passed with warnings");
    } else {
      ImGui::TextColored(gui::GetErrorColor(),
                         ICON_MD_CANCEL " Critical violations found");
    }
 
    ImGui::Separator();
 
    // Show critical violations
    if (!result.critical_violations.empty()) {
      ImGui::TextColored(gui::GetErrorColor(),
                         ICON_MD_BLOCK " Critical Violations:");
      for (const auto& violation : result.critical_violations) {
        ImGui::Bullet();
        ImGui::TextWrapped("%s: %s", violation.policy_name.c_str(),
                           violation.message.c_str());
        if (!violation.details.empty()) {
          ImGui::Indent();
          ImGui::TextColored(gui::GetDisabledColor(), "%s",
                             violation.details.c_str());
          ImGui::Unindent();
        }
      }
      ImGui::Separator();
    }
 
    // Show warnings
    if (!result.warnings.empty()) {
      ImGui::TextColored(gui::GetWarningColor(), ICON_MD_WARNING " Warnings:");
      for (const auto& violation : result.warnings) {
        ImGui::Bullet();
        ImGui::TextWrapped("%s: %s", violation.policy_name.c_str(),
                           violation.message.c_str());
        if (!violation.details.empty()) {
          ImGui::Indent();
          ImGui::TextColored(gui::GetDisabledColor(), "%s",
                             violation.details.c_str());
          ImGui::Unindent();
        }
      }
      ImGui::Separator();
    }
 
    // Show info messages
    if (!result.info.empty()) {
      ImGui::TextColored(gui::GetInfoColor(), ICON_MD_INFO " Information:");
      for (const auto& violation : result.info) {
        ImGui::Bullet();
        ImGui::TextWrapped("%s: %s", violation.policy_name.c_str(),
                           violation.message.c_str());
      }
    }
  }
#endif  // YAZE_ENABLE_POLICY_FRAMEWORK
}
 
void ProposalDrawer::DrawActionButtons() {
  if (!selected_proposal_)
    return;
 
  const auto& p = *selected_proposal_;
  bool is_pending = p.status == cli::ProposalRegistry::ProposalStatus::kPending;
 
  if (is_pending) {
    if (ImGui::Button(ICON_MD_CHECK " Accept", ImVec2(-1, 0))) {
      action_status_ = AcceptProposal(p.id);
      action_feedback_.clear();
    }
 
    // Reject button (only for pending proposals)
    if (ImGui::Button(ICON_MD_CLOSE " Reject", ImVec2(-1, 0))) {
      confirm_action_ = "reject";
      confirm_proposal_id_ = p.id;
      show_confirm_dialog_ = true;
    }
  }
 
  // Delete button (for all proposals)
  if (ImGui::Button(ICON_MD_DELETE " Delete", ImVec2(-1, 0))) {
    confirm_action_ = "delete";
    confirm_proposal_id_ = p.id;
    show_confirm_dialog_ = true;
  }
}
 
void ProposalDrawer::FocusProposal(const std::string& proposal_id) {
  visible_ = true;
  selected_proposal_id_ = proposal_id;
  selected_proposal_ = nullptr;
  needs_refresh_ = true;
}
 
void ProposalDrawer::RefreshProposals() {
#ifdef Z3ED_AI
  auto& registry = cli::ProposalRegistry::Instance();
 
  std::optional<cli::ProposalRegistry::ProposalStatus> filter;
  switch (status_filter_) {
    case StatusFilter::kPending:
      filter = cli::ProposalRegistry::ProposalStatus::kPending;
      break;
    case StatusFilter::kAccepted:
      filter = cli::ProposalRegistry::ProposalStatus::kAccepted;
      break;
    case StatusFilter::kRejected:
      filter = cli::ProposalRegistry::ProposalStatus::kRejected;
      break;
    case StatusFilter::kAll:
      filter = std::nullopt;
      break;
  }
 
  // Replacing the list invalidates pointers into the previous vector.
  const std::string selected_id = selected_proposal_id_;
  selected_proposal_ = nullptr;
  proposals_ = registry.ListProposals(filter);
  SelectProposal(selected_id);
  if (!selected_proposal_)
    selected_proposal_id_.clear();
#endif
}
 
void ProposalDrawer::SelectProposal(const std::string& proposal_id) {
  selected_proposal_id_ = proposal_id;
  selected_proposal_ = nullptr;
  diff_content_.clear();
  log_content_.clear();
 
  // Find the proposal in our list
  for (auto& p : proposals_) {
    if (p.id == proposal_id) {
      selected_proposal_ = &p;
      break;
    }
  }
}
 
absl::Status ProposalDrawer::AcceptProposal(const std::string&) {
  return absl::UnimplementedError(
      "Proposal apply is unavailable. Preview the changes and apply them "
      "through the normal editor.");
}
 
absl::Status ProposalDrawer::RejectProposal(const std::string& proposal_id) {
#ifdef Z3ED_AI
  auto& registry = cli::ProposalRegistry::Instance();
  auto status = registry.UpdateStatus(
      proposal_id, cli::ProposalRegistry::ProposalStatus::kRejected);
 
  needs_refresh_ = true;
  return status;
#else
  return absl::UnimplementedError("AI features disabled");
#endif
}
 
absl::Status ProposalDrawer::DeleteProposal(const std::string& proposal_id) {
#ifdef Z3ED_AI
  auto& registry = cli::ProposalRegistry::Instance();
  auto status = registry.RemoveProposal(proposal_id);
 
  if (proposal_id == selected_proposal_id_) {
    selected_proposal_id_.clear();
    selected_proposal_ = nullptr;
    diff_content_.clear();
    log_content_.clear();
  }
 
  needs_refresh_ = true;
  return status;
#else
  return absl::UnimplementedError("AI features disabled");
#endif
}
 
}  // namespace editor
}  // namespace yaze