@bniladridas/cursor 0.1.7

package/src/utils/ui.cpp

@@ -0,0 +1,307 @@
+#include "utils/ui.h"
+#include <array>
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <thread>
+
+namespace Utils {
+
+// ===== Color Codes =====
+namespace Color {
+// Exported color constants
+CURSOR_API const std::string RESET = "\033[0m";
+CURSOR_API const std::string GREEN = "\033[32m";
+CURSOR_API const std::string YELLOW = "\033[33m";
+CURSOR_API const std::string RED = "\033[31m";
+CURSOR_API const std::string CYAN = "\033[36m";
+CURSOR_API const std::string BOLD = "\033[1m";
+CURSOR_API const std::string DIM = "\033[2m";
+CURSOR_API const std::string PINK = "\033[38;2;255;105;180m";
+} // namespace Color
+
+// ===== Logo =====
+void UI::print_logo() {
+  std::cout << Color::PINK
+            << "        ▄▄▄▄▄▄▄▄▄▄▄\n"
+            << "       █           █\n"
+            << "      █   ▄▄▄▄▄▄   █\n"
+            << "     █   █      █   █\n"
+            << "    █   █   ██   █   █\n"
+            << "    █   █  █  █  █   █\n"
+            << "    █   █  █  █  █   █\n"
+            << "    █   █   ██   █   █\n"
+            << "     █   █       █  █\n"
+            << "      █   ▀▀▀▀▀▀  █\n"
+            << "       █         █\n"
+            << "        ▀▀▀▀▀▀▀▀▀\n"
+            << Color::RESET
+            << Color::BOLD << "          CURSOR\n"
+            << Color::RESET;
+
+  std::cout << Color::DIM << "Welcome to Cursor - Choose your mode below.\n"
+            << Color::RESET;
+
+  print_divider();
+}
+
+// ===== Help Menu =====
+void UI::print_help() {
+
+  std::cout << Color::BOLD << "Commands\n" << Color::RESET;
+  print_divider();
+
+  // File Operations
+  std::cout << Color::GREEN << "Files\n" << Color::RESET;
+  std::cout << Color::CYAN << "  @file <path>" << Color::RESET
+            << "             - Inject file\n";
+  std::cout << Color::CYAN << "  @directory <path>" << Color::RESET
+            << "        - Inject directory\n";
+  std::cout << Color::CYAN << "  read:<file>" << Color::RESET
+            << "              - Read file\n";
+  std::cout << Color::CYAN << "  read:<file>:<start>:<count>" << Color::RESET
+            << " - Read range\n";
+  std::cout << Color::CYAN << "  write:<file> <content>" << Color::RESET
+            << "   - Write file\n";
+  std::cout << Color::CYAN << "  replace:<file>:<old>:<new>" << Color::RESET
+            << " - Replace text\n";
+  std::cout << Color::CYAN << "  grep:<pattern>[:dir[:filter]]" << Color::RESET
+            << " - Search text\n";
+
+  // Sessions
+  std::cout << "\n" << Color::GREEN << "Sessions\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /save <name> [tags]" << Color::RESET
+            << "       - Save session\n";
+  std::cout << Color::CYAN << "  /resume <name>" << Color::RESET
+            << "           - Resume session\n";
+  std::cout << Color::CYAN << "  /sessions" << Color::RESET
+            << "               - List sessions\n";
+  std::cout << Color::CYAN << "  /compress" << Color::RESET
+            << "               - Compress context\n";
+  std::cout << Color::CYAN << "  remember:<fact>" << Color::RESET
+            << "          - Remember fact\n";
+  std::cout << Color::CYAN << "  memory" << Color::RESET
+            << "                  - Show memory\n";
+  std::cout << Color::CYAN << "  clear" << Color::RESET
+            << "                   - Clear session\n";
+  std::cout << Color::CYAN << "  forget" << Color::RESET
+            << "                  - Clear memory\n";
+
+  // Web
+  std::cout << "\n" << Color::GREEN << "Web\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /fetch <url> [format]" << Color::RESET
+            << "     - Fetch content\n";
+  std::cout << Color::CYAN << "  search:<query>" << Color::RESET
+            << "            - Search web\n";
+  std::cout << Color::CYAN << "  /mcp servers" << Color::RESET
+            << "             - List servers\n";
+  std::cout << Color::CYAN << "  /mcp resources <server>" << Color::RESET
+            << "   - List resources\n";
+  std::cout << Color::CYAN << "  /mcp tools <server>" << Color::RESET
+            << "       - List tools\n";
+
+  // Checkpoints
+  std::cout << "\n" << Color::GREEN << "Checkpoints\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /checkpoint <name>" << Color::RESET
+            << "        - Create checkpoint\n";
+  std::cout << Color::CYAN << "  /restore <name>" << Color::RESET
+            << "          - Restore checkpoint\n";
+  std::cout << Color::CYAN << "  /checkpoints" << Color::RESET
+            << "             - List checkpoints\n";
+
+  // Themes
+  std::cout << "\n" << Color::GREEN << "Themes\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /theme list" << Color::RESET
+            << "              - List themes\n";
+  std::cout << Color::CYAN << "  /theme set <name>" << Color::RESET
+            << "         - Set theme\n";
+  std::cout << Color::CYAN << "  /theme preview <name>" << Color::RESET
+            << "     - Preview theme\n";
+
+  // Security
+  std::cout << "\n" << Color::GREEN << "Security\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /auth providers" << Color::RESET
+            << "           - List providers\n";
+  std::cout << Color::CYAN << "  /auth set <provider>" << Color::RESET
+            << "      - Set provider\n";
+  std::cout << Color::CYAN << "  /auth key <provider> <key>" << Color::RESET
+            << " - Set key\n";
+  std::cout << Color::CYAN << "  /sandbox run <command>" << Color::RESET
+            << "    - Run sandboxed\n";
+  std::cout << Color::CYAN << "  /sandbox status" << Color::RESET
+            << "           - Check status\n";
+
+  // Errors
+  std::cout << "\n" << Color::GREEN << "Errors\n" << Color::RESET;
+  std::cout << Color::CYAN << "  /error report" << Color::RESET
+            << "             - View errors\n";
+  std::cout << Color::CYAN << "  /error recent <count>" << Color::RESET
+            << "     - Show recent\n";
+  std::cout << Color::CYAN << "  /error export <file>" << Color::RESET
+            << "      - Export log\n";
+
+  // System
+  std::cout << "\n" << Color::GREEN << "System\n" << Color::RESET;
+  std::cout << Color::CYAN << "  cmd:<command>" << Color::RESET
+            << "            - Execute shell command\n";
+  std::cout << Color::CYAN << "  /update" << Color::RESET
+            << "                  - Check for updates\n";
+  std::cout << Color::CYAN << "  /tools" << Color::RESET
+            << "                   - Show tools\n";
+  std::cout << Color::CYAN << "  !" << Color::RESET
+            << "                        - Toggle shell\n";
+  std::cout << Color::CYAN << "  help" << Color::RESET
+            << "                    - Show help\n";
+  std::cout << Color::CYAN << "  quit" << Color::RESET
+            << "                    - Exit\n";
+
+  std::cout << "\n" << Color::BOLD << "Notes\n" << Color::RESET;
+  std::cout << Color::DIM << "Set theme with /theme set dark\n" << Color::RESET;
+  std::cout << Color::DIM << "Configure auth with /auth key\n" << Color::RESET;
+  std::cout << Color::DIM << "Create checkpoints before changes\n"
+            << Color::RESET;
+  std::cout << Color::DIM << "Use /sandbox for safe execution\n"
+            << Color::RESET;
+  print_divider();
+}
+
+// ===== Status =====
+void UI::print_enterprise_status() {
+  std::cout << Color::BOLD << "Status\n" << Color::RESET;
+  print_divider();
+
+  std::cout << Color::GREEN << "Files (4/4)\n" << Color::RESET;
+  std::cout << Color::DIM << "   File injection\n" << Color::RESET;
+  std::cout << Color::DIM << "   Multi-file operations\n" << Color::RESET;
+  std::cout << Color::DIM << "   Context hierarchy\n" << Color::RESET;
+  std::cout << Color::DIM << "   Shell integration\n" << Color::RESET;
+
+  std::cout << "\n" << Color::GREEN << "Sessions (4/4)\n" << Color::RESET;
+  std::cout << Color::DIM << "   Session management\n" << Color::RESET;
+  std::cout << Color::DIM << "   Tool registry\n" << Color::RESET;
+  std::cout << Color::DIM << "   Configuration\n" << Color::RESET;
+  std::cout << Color::DIM << "   Context compression\n" << Color::RESET;
+
+  std::cout << "\n" << Color::GREEN << "Extensions (4/4)\n" << Color::RESET;
+  std::cout << Color::DIM << "   MCP servers\n" << Color::RESET;
+  std::cout << Color::DIM << "   Checkpoints\n" << Color::RESET;
+  std::cout << Color::DIM << "   Web fetch\n" << Color::RESET;
+  std::cout << Color::DIM << "   File filtering\n" << Color::RESET;
+
+  std::cout << "\n" << Color::GREEN << "Security (4/4)\n" << Color::RESET;
+  std::cout << Color::DIM << "   Themes\n" << Color::RESET;
+  std::cout << Color::DIM << "   Authentication\n" << Color::RESET;
+  std::cout << Color::DIM << "   Sandboxing\n" << Color::RESET;
+  std::cout << Color::DIM << "   Error handling\n" << Color::RESET;
+
+  std::cout << "\n"
+            << Color::BOLD << Color::GREEN << "16 features active\n"
+            << Color::RESET;
+  print_divider();
+}
+
+// ===== Spinner =====
+void UI::spinner(const std::string &message, int duration_ms) {
+  const std::array<std::string_view, 4> frames = {"/", "-", "\\", "|"};
+  const size_t num_frames = frames.size();
+  size_t frame = 0;
+  auto start = std::chrono::steady_clock::now();
+
+  std::cout << Color::CYAN << message << " " << Color::RESET;
+  while (std::chrono::steady_clock::now() - start <
+         std::chrono::milliseconds(duration_ms)) {
+    std::cout << "\b" << frames[frame] << std::flush;
+    frame = (frame + 1) % num_frames;
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  std::cout << "\b" << " " << "\n";
+}
+
+// ===== Threaded Spinner =====
+void UI::spinner(std::atomic<bool> &done) {
+  const char frames[] = {'|', '/', '-', '\\'};
+  int frame = 0;
+
+  while (!done) {
+    std::cout << "\r" << frames[frame % 4] << std::flush;
+    frame++;
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  std::cout << "\r \r" << std::flush;
+}
+
+// ===== Status Messages =====
+void UI::print_success(const std::string &message) {
+  std::cout << Color::GREEN << "[OK] " << Color::RESET << message << "\n";
+}
+
+void UI::print_error(const std::string &message) {
+  std::cout << Color::RED << "[ERROR] " << Color::RESET << message << "\n";
+}
+
+void UI::print_warning(const std::string &message) {
+  std::cout << Color::YELLOW << "[WARN] " << Color::RESET << message << "\n";
+}
+
+void UI::print_info(const std::string &message) {
+  std::cout << Color::CYAN << "[INFO] " << Color::RESET << message << "\n";
+}
+
+// ===== Divider =====
+void UI::print_divider() {
+  std::cout << Color::DIM << "----------------------------------------\n"
+            << Color::RESET;
+}
+
+// ===== Quick Help Interface =====
+void UI::print_quick_help() {
+  std::cout << Color::DIM << "Quick Commands: " << Color::RESET;
+  std::cout << Color::CYAN << "help" << Color::RESET << " | ";
+
+  std::cout << Color::CYAN << "search:query" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "cmd:command" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "read:file" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "quit" << Color::RESET << "\n";
+
+  std::cout << Color::CYAN << "version" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "update" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "search:query" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "cmd:command" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "read:file" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "write:file text" << Color::RESET << " | ";
+  std::cout << Color::CYAN << "exit" << Color::RESET << "\n";
+
+  print_divider();
+}
+
+// ===== System Info =====
+void UI::print_system_info(const std::string &mode, const std::string &model) {
+  std::cout << Color::DIM << "System: " << Color::RESET;
+  std::cout << Color::GREEN << "Mode=" << mode << Color::RESET << " | ";
+  std::cout << Color::GREEN << "Model=" << model << Color::RESET << " | ";
+  std::cout << Color::GREEN << "Memory=Active" << Color::RESET << " | ";
+  std::cout << Color::GREEN << "Commands=Available" << Color::RESET << "\n";
+}
+
+// ===== Ready Interface =====
+void UI::print_ready_interface(const std::string &mode,
+                               const std::string &model) {
+  print_system_info(mode, model);
+  print_quick_help();
+
+  std::cout << "Ready - Type a command:\n";
+
+  std::cout << "Ready - Type a command or chat naturally:\n";
+}
+
+// ===== Prompted Input =====
+std::string UI::prompt_user(const std::string &prompt_text) {
+  // Only print the prompt once with consistent formatting
+  std::cout << Color::BOLD << "[You] " << prompt_text << Color::RESET << " > ";
+
+  std::string input;
+  std::getline(std::cin, input);
+  return input;
+}
+
+} // namespace Utils

package/src/utils/validation.cpp

@@ -0,0 +1,306 @@
+#include "utils/validation.h"
+#include "services/file_service.h"
+#include <algorithm>
+#include <cctype>
+#include <filesystem>
+#include <regex>
+
+namespace Utils {
+
+ValidationResult
+Validator::validate_file_path(const std::string &path,
+                              const std::string &base_directory) {
+  ValidationResult result = {true, "", {}};
+
+  if (path.empty()) {
+    result.is_valid = false;
+    result.error_message = "File path cannot be empty";
+    return result;
+  }
+
+  // Check for dangerous path patterns
+  if (path.find("..") != std::string::npos) {
+    result.warnings.push_back("Path contains '..' which may be unsafe");
+  }
+
+  // Validate against base directory if provided
+  if (!base_directory.empty()) {
+    if (!Services::FileService::is_within_directory(path, base_directory)) {
+      result.is_valid = false;
+      result.error_message = "Path is outside the allowed base directory";
+      return result;
+    }
+  }
+
+  // Check path length
+  if (path.length() > 260) { // Windows MAX_PATH limit
+    result.warnings.push_back(
+        "Path is very long and may cause issues on some systems");
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_file_exists(const std::string &path) {
+  ValidationResult result = {true, "", {}};
+
+  if (!Services::FileService::file_exists(path)) {
+    result.is_valid = false;
+    result.error_message = "File does not exist: " + path;
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_file_writable(const std::string &path) {
+  ValidationResult result = {true, "", {}};
+
+  try {
+    std::filesystem::path file_path(path);
+    std::filesystem::path parent_path = file_path.parent_path();
+
+    // Check if parent directory exists and is writable
+    if (!parent_path.empty() && !std::filesystem::exists(parent_path)) {
+      // Try to create parent directories
+      try {
+        std::filesystem::create_directories(parent_path);
+      } catch (const std::exception &e) {
+        result.is_valid = false;
+        result.error_message =
+            "Cannot create parent directory: " + std::string(e.what());
+        return result;
+      }
+    }
+
+    // Check if file exists and is writable
+    if (std::filesystem::exists(path)) {
+      auto perms = std::filesystem::status(path).permissions();
+      if ((perms & std::filesystem::perms::owner_write) ==
+          std::filesystem::perms::none) {
+        result.warnings.push_back("File may not be writable");
+      }
+    }
+
+  } catch (const std::exception &e) {
+    result.is_valid = false;
+    result.error_message =
+        "Error checking file writability: " + std::string(e.what());
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_non_empty(const std::string &text,
+                                               const std::string &field_name) {
+  ValidationResult result = {true, "", {}};
+
+  if (text.empty()) {
+    result.is_valid = false;
+    result.error_message = field_name + " cannot be empty";
+  } else if (text.find_first_not_of(" \t\n\r") == std::string::npos) {
+    result.is_valid = false;
+    result.error_message = field_name + " cannot be only whitespace";
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_regex_pattern(const std::string &pattern) {
+  ValidationResult result = {true, "", {}};
+
+  try {
+    std::regex test_regex(pattern);
+    (void)test_regex; // Suppress unused variable warning - we only care about
+                      // construction validity
+  } catch (const std::regex_error &e) {
+    result.is_valid = false;
+    result.error_message =
+        "Invalid regular expression: " + std::string(e.what());
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_command_safe(const std::string &command) {
+  ValidationResult result = {true, "", {}};
+
+  // List of potentially dangerous commands
+  static const std::vector<std::string> dangerous_commands = {
+      "rm",     "del",  "format",   "fdisk", "mkfs", "dd",      "shutdown",
+      "reboot", "halt", "poweroff", "init",  "kill", "killall", "pkill"};
+
+  std::string lower_command = command;
+  std::transform(lower_command.begin(), lower_command.end(),
+                 lower_command.begin(), ::tolower);
+
+  for (const auto &dangerous : dangerous_commands) {
+    if (lower_command.find(dangerous) != std::string::npos) {
+      result.warnings.push_back(
+          "Command contains potentially dangerous operation: " + dangerous);
+      break;
+    }
+  }
+
+  // Check for shell injection patterns
+  if (command.find(";") != std::string::npos ||
+      command.find("&&") != std::string::npos ||
+      command.find("||") != std::string::npos ||
+      command.find("|") != std::string::npos) {
+    result.warnings.push_back(
+        "Command contains shell operators that may be unsafe");
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_search_query(const std::string &query) {
+  ValidationResult result = validate_non_empty(query, "Search query");
+
+  if (result.is_valid) {
+    if (query.length() > 1000) {
+      result.warnings.push_back("Search query is very long");
+    }
+
+    // Check for potentially problematic characters
+    if (query.find_first_of("<>\"'&") != std::string::npos) {
+      result.warnings.push_back(
+          "Query contains special characters that may affect search results");
+    }
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_line_range(int start_line, int line_count,
+                                                int total_lines) {
+  ValidationResult result = {true, "", {}};
+
+  if (start_line < 0) {
+    result.is_valid = false;
+    result.error_message = "Start line cannot be negative";
+    return result;
+  }
+
+  if (line_count < -1) {
+    result.is_valid = false;
+    result.error_message = "Line count must be -1 (all) or positive";
+    return result;
+  }
+
+  if (total_lines >= 0) {
+    if (start_line >= total_lines) {
+      result.is_valid = false;
+      result.error_message = "Start line is beyond end of file";
+      return result;
+    }
+
+    if (line_count > 0 && start_line + line_count > total_lines) {
+      result.warnings.push_back("Requested range extends beyond end of file");
+    }
+  }
+
+  return result;
+}
+
+ValidationResult Validator::validate_replacement_count(int expected,
+                                                       int actual) {
+  ValidationResult result = {true, "", {}};
+
+  if (expected > 0 && expected != actual) {
+    result.is_valid = false;
+    result.error_message = "Expected " + std::to_string(expected) +
+                           " replacements but found " + std::to_string(actual);
+  } else if (actual == 0) {
+    result.is_valid = false;
+    result.error_message = "No matches found for replacement";
+  }
+
+  return result;
+}
+
+ValidationResult
+Validator::combine_results(const std::vector<ValidationResult> &results) {
+  ValidationResult combined = {true, "", {}};
+
+  for (const auto &result : results) {
+    if (!result.is_valid) {
+      combined.is_valid = false;
+      if (combined.error_message.empty()) {
+        combined.error_message = result.error_message;
+      } else {
+        combined.error_message += "; " + result.error_message;
+      }
+    }
+
+    // Combine warnings
+    combined.warnings.insert(combined.warnings.end(), result.warnings.begin(),
+                             result.warnings.end());
+  }
+
+  return combined;
+}
+
+bool Validator::is_safe_path(const std::string &path) {
+  // Check for path traversal attempts
+  if (path.find("..") != std::string::npos)
+    return false;
+
+  // Check for absolute paths that might be dangerous
+  if (path.find("/etc/") == 0 || path.find("/sys/") == 0 ||
+      path.find("/proc/") == 0 || path.find("/dev/") == 0) {
+    return false;
+  }
+
+  // Check for Windows system paths
+  if (path.find("C:\\Windows\\") == 0 || path.find("C:\\System32\\") == 0) {
+    return false;
+  }
+
+  return true;
+}
+
+bool Validator::is_text_file_extension(const std::string &extension) {
+  const auto &text_extensions = get_text_extensions();
+
+  std::string lower_ext = extension;
+  std::transform(lower_ext.begin(), lower_ext.end(), lower_ext.begin(),
+                 ::tolower);
+
+  return std::find(text_extensions.begin(), text_extensions.end(), lower_ext) !=
+         text_extensions.end();
+}
+
+const std::vector<std::string> &Validator::get_text_extensions() {
+  static const std::vector<std::string> text_extensions = {
+      ".txt",   ".md",     ".rst",   ".log",  ".cfg",        ".conf",
+      ".ini",   ".yaml",   ".yml",   ".json", ".xml",        ".html",
+      ".htm",   ".css",    ".js",    ".ts",   ".jsx",        ".tsx",
+      ".c",     ".cpp",    ".cc",    ".cxx",  ".h",          ".hpp",
+      ".hxx",   ".java",   ".py",    ".rb",   ".go",         ".rs",
+      ".php",   ".pl",     ".sh",    ".bash", ".zsh",        ".fish",
+      ".ps1",   ".sql",    ".r",     ".m",    ".swift",      ".kt",
+      ".scala", ".clj",    ".hs",    ".ml",   ".dockerfile", ".makefile",
+      ".cmake", ".gradle", ".maven", ".sbt",  ".bat",        ".csv",
+      ".tsv"};
+  return text_extensions;
+}
+
+std::string Validator::sanitize_input(const std::string &input) {
+  std::string sanitized = input;
+
+  // Remove null bytes
+  sanitized.erase(std::remove(sanitized.begin(), sanitized.end(), '\0'),
+                  sanitized.end());
+
+  // Trim whitespace
+  size_t start = sanitized.find_first_not_of(" \t\n\r");
+  if (start == std::string::npos)
+    return "";
+
+  size_t end = sanitized.find_last_not_of(" \t\n\r");
+  sanitized = sanitized.substr(start, end - start + 1);
+
+  return sanitized;
+}
+
+} // namespace Utils