@bniladridas/cursor 0.1.7

package/src/services/command_service.cpp

@@ -0,0 +1,82 @@
+#include "services/command_service.h"
+
+#include "utils/platform.h"
+
+#include <array>
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <future>
+#include <regex>
+#include <stdexcept>
+
+namespace Services {
+const std::array<std::string, 9> CommandService::dangerous_commands = {
+    "rm",     "sudo rm", "format", "del /", "shutdown",
+    "reboot", "mkfs",    "fdisk",  "dd"};
+
+bool CommandService::is_dangerous_command(const std::string &command) {
+  // Token-based matching to avoid substring false positives
+  for (const auto &danger : dangerous_commands) {
+    std::regex pattern(
+        "\\b" + std::regex_replace(danger, std::regex(" "), "\\s+") + "\\b");
+    if (std::regex_search(command, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string
+CommandService::execute_command([[maybe_unused]] const std::string &command,
+                                FILE *pipe) {
+  if (!pipe) {
+    throw std::runtime_error("Failed to execute command");
+  }
+
+  std::string result;
+  char buffer[256];
+  size_t total_bytes = 0;
+  const size_t MAX_BYTES = 10 * 1024; // 10 KB limit
+
+  while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
+    total_bytes += strlen(buffer);
+    if (total_bytes > MAX_BYTES) {
+      result += "\n[Output truncated]";
+      break;
+    }
+    result += buffer;
+  }
+
+  int exit_code = Utils::Platform::close_process(pipe);
+  if (exit_code != 0) {
+    result += "\nExit code: " + std::to_string(exit_code);
+  }
+
+  return result.empty() ? "Command completed" : result;
+}
+
+std::string CommandService::execute(const std::string &command) {
+  if (is_dangerous_command(command)) {
+    return "Error: Dangerous command blocked";
+  }
+
+  try {
+    auto future = std::async(std::launch::async, [&]() -> std::string {
+      // Use platform-agnostic process handling
+      FILE *pipe = Utils::Platform::open_process(
+          command + Utils::Platform::get_shell_redirect_both(), "r");
+      return execute_command(command, pipe);
+    });
+
+    // Timeout: 5 seconds
+    if (future.wait_for(std::chrono::seconds(5)) ==
+        std::future_status::timeout) {
+      return "Error: Command timed out";
+    }
+    return future.get();
+  } catch (const std::exception &e) {
+    return std::string("Error executing command: ") + e.what();
+  }
+}
+} // namespace Services

package/src/services/context_service.cpp

@@ -0,0 +1,348 @@
+#include "services/context_service.h"
+#include <algorithm>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+namespace Services {
+
+// Static member definitions
+std::map<std::string, std::string> ContextService::context_cache;
+std::string ContextService::cached_working_directory;
+
+std::string ContextService::load_hierarchical_context(
+    const std::string &working_directory) {
+  // Check cache first
+  if (cached_working_directory == working_directory &&
+      context_cache.find("hierarchical") != context_cache.end()) {
+    return context_cache["hierarchical"];
+  }
+
+  std::vector<ContextFile> all_files = find_context_files(working_directory);
+  std::string merged_context = merge_context_files(all_files);
+
+  // Update cache
+  cached_working_directory = working_directory;
+  context_cache["hierarchical"] = merged_context;
+
+  return merged_context;
+}
+
+std::vector<ContextFile>
+ContextService::find_context_files(const std::string &working_directory) {
+  std::vector<ContextFile> files;
+
+  // 1. Load global context (highest priority)
+  ContextFile global_context = load_global_context();
+  if (!global_context.content.empty()) {
+    files.push_back(global_context);
+  }
+
+  // 2. Load project context files (from root to current)
+  auto project_files = load_project_context(working_directory);
+  files.insert(files.end(), project_files.begin(), project_files.end());
+
+  // 3. Load local context files (current directory and subdirectories)
+  auto local_files = load_local_context(working_directory);
+  files.insert(files.end(), local_files.begin(), local_files.end());
+
+  // Sort by priority (higher priority first)
+  std::sort(files.begin(), files.end(),
+            [](const ContextFile &a, const ContextFile &b) {
+              return a.priority > b.priority;
+            });
+
+  return files;
+}
+
+ContextFile ContextService::load_global_context() {
+  ContextFile context;
+  context.source = "global";
+  context.priority = 100; // Highest priority
+
+  std::string home_dir = get_home_directory();
+  if (home_dir.empty()) {
+    return context;
+  }
+
+  std::string global_path = home_dir + "/.cursor/CURSOR.md";
+
+  if (is_readable_file(global_path)) {
+    context.file_path = global_path;
+    context.content = load_file_content(global_path);
+  }
+
+  return context;
+}
+
+std::vector<ContextFile>
+ContextService::load_project_context(const std::string &working_directory) {
+  std::vector<ContextFile> files;
+
+  // Find project root
+  std::string project_root = find_project_root(working_directory);
+  if (project_root.empty()) {
+    return files;
+  }
+
+  // Walk from project root to current directory
+  std::filesystem::path current_path =
+      std::filesystem::absolute(working_directory);
+  std::filesystem::path root_path = std::filesystem::absolute(project_root);
+
+  std::vector<std::filesystem::path> path_hierarchy;
+
+  // Build path hierarchy from root to current
+  std::filesystem::path temp_path = current_path;
+  while (temp_path != root_path && temp_path.has_parent_path()) {
+    path_hierarchy.push_back(temp_path);
+    temp_path = temp_path.parent_path();
+  }
+  path_hierarchy.push_back(root_path);
+
+  // Reverse to go from root to current
+  std::reverse(path_hierarchy.begin(), path_hierarchy.end());
+
+  // Load CURSOR.md files in hierarchy order
+  int priority = 90; // Start below global priority
+  for (const auto &path : path_hierarchy) {
+    std::string context_file = path.string() + "/CURSOR.md";
+
+    if (is_readable_file(context_file)) {
+      ContextFile context;
+      context.file_path = context_file;
+      context.content = load_file_content(context_file);
+      context.priority = priority;
+      context.source = "project";
+
+      files.push_back(context);
+    }
+
+    priority -= 10; // Decrease priority as we go deeper
+  }
+
+  return files;
+}
+
+std::vector<ContextFile>
+ContextService::load_local_context(const std::string &working_directory) {
+  std::vector<ContextFile> files;
+
+  try {
+    // Look for CURSOR.md files in subdirectories
+    for (const auto &entry :
+         std::filesystem::recursive_directory_iterator(working_directory)) {
+      if (entry.is_regular_file() &&
+          entry.path().filename() == "CURSOR.md") {
+
+        std::string entry_path = entry.path().string();
+
+        // Simple check - if it's in a parent directory, skip
+        std::filesystem::path rel_path =
+            std::filesystem::relative(entry.path(), working_directory);
+        if (rel_path.string().find("..") == 0) {
+          continue;
+        }
+
+        ContextFile context;
+        context.file_path = entry_path;
+        context.content = load_file_content(entry_path);
+        context.priority = 10; // Lower priority than project files
+        context.source = "local";
+
+        files.push_back(context);
+      }
+    }
+  } catch (const std::exception &e) {
+    std::cerr << "Error loading local context: " << e.what() << std::endl;
+  }
+
+  return files;
+}
+
+std::string
+ContextService::merge_context_files(const std::vector<ContextFile> &files) {
+  if (files.empty()) {
+    return "";
+  }
+
+  std::ostringstream merged;
+  merged << "# Cursor Context\n\n";
+
+  // Group files by source
+  std::map<std::string, std::vector<const ContextFile *>> files_by_source;
+  for (const auto &file : files) {
+    files_by_source[file.source].push_back(&file);
+  }
+
+  // Output in order: global, project, local
+  std::vector<std::string> source_order = {"global", "project", "local"};
+
+  for (const auto &source : source_order) {
+    if (files_by_source.find(source) == files_by_source.end()) {
+      continue;
+    }
+
+    merged << "## " << source << " Context\n\n";
+
+    for (const auto *file : files_by_source[source]) {
+      std::string display_path = get_display_path(file->file_path, ".");
+      merged << "### From: " << display_path << "\n\n";
+      merged << file->content;
+
+      if (!file->content.empty() && file->content.back() != '\n') {
+        merged << "\n";
+      }
+      merged << "\n";
+    }
+  }
+
+  return merged.str();
+}
+
+std::string
+ContextService::find_project_root(const std::string &starting_directory) {
+  std::filesystem::path current_path =
+      std::filesystem::absolute(starting_directory);
+
+  while (current_path.has_parent_path()) {
+    if (is_project_root(current_path.string())) {
+      return current_path.string();
+    }
+    current_path = current_path.parent_path();
+  }
+
+  return ""; // No project root found
+}
+
+bool ContextService::is_project_root(const std::string &directory) {
+  std::vector<std::string> project_markers = {
+      ".git",       "package.json", "CMakeLists.txt", "Makefile",
+      "Cargo.toml", "pom.xml",      "build.gradle",   "requirements.txt",
+      "setup.py",   "go.mod",       ".gitignore"};
+
+  for (const auto &marker : project_markers) {
+    std::string marker_path = directory + "/" + marker;
+    if (std::filesystem::exists(marker_path)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void ContextService::refresh_context_cache() {
+  context_cache.clear();
+  cached_working_directory.clear();
+}
+
+std::string ContextService::get_context_template() {
+  return R"(# Cursor Context File
+
+This file provides context and instructions for Cursor AI assistant.
+
+## Project Overview
+
+Brief description of this project/component.
+
+## Key Information
+
+- Important facts about the codebase
+- Coding standards and conventions
+- Architecture decisions
+- Dependencies and requirements
+
+## Instructions for AI
+
+- Specific guidance for AI when working in this context
+- Preferred approaches or patterns
+- Things to avoid or be careful about
+
+## Examples
+
+```
+Example code or commands that are commonly used in this context
+```
+
+## References
+
+- Links to documentation
+- Related files or components
+- External resources
+)";
+}
+
+bool ContextService::create_context_file(const std::string &directory,
+                                         const std::string &content) {
+  try {
+    std::string file_path = directory + "/CURSOR.md";
+
+    // Don't overwrite existing file
+    if (std::filesystem::exists(file_path)) {
+      return false;
+    }
+
+    std::ofstream file(file_path);
+    if (!file.is_open()) {
+      return false;
+    }
+
+    if (content.empty()) {
+      file << get_context_template();
+    } else {
+      file << content;
+    }
+
+    return true;
+  } catch (const std::exception &) {
+    return false;
+  }
+}
+
+std::string ContextService::get_home_directory() {
+  const char *home = std::getenv("HOME");
+  if (!home) {
+    home = std::getenv("USERPROFILE"); // Windows
+  }
+  return home ? std::string(home) : "";
+}
+
+bool ContextService::is_readable_file(const std::string &file_path) {
+  try {
+    return std::filesystem::exists(file_path) &&
+           std::filesystem::is_regular_file(file_path);
+  } catch (const std::exception &) {
+    return false;
+  }
+}
+
+std::string ContextService::load_file_content(const std::string &file_path) {
+  try {
+    std::ifstream file(file_path);
+    if (!file.is_open()) {
+      return "";
+    }
+
+    std::ostringstream content;
+    content << file.rdbuf();
+    return content.str();
+  } catch (const std::exception &) {
+    return "";
+  }
+}
+
+std::string
+ContextService::get_display_path(const std::string &file_path,
+                                 const std::string &base_directory) {
+  try {
+    std::filesystem::path rel_path =
+        std::filesystem::relative(file_path, base_directory);
+    return rel_path.string();
+  } catch (const std::exception &) {
+    return file_path;
+  }
+}
+
+} // namespace Services

package/src/services/database_service.cpp

@@ -0,0 +1,148 @@
+#include "services/database_service.h"
+#include <iostream>
+#include <vector>
+
+namespace cursor {
+
+DatabaseService::DatabaseService()
+#ifdef HAVE_PQXX
+    : connection_(nullptr)
+#endif
+{
+}
+
+DatabaseService::~DatabaseService() { disconnect(); }
+
+bool DatabaseService::connect(const std::string &host, int port,
+                              const std::string &dbname,
+                              const std::string &user,
+                              const std::string &password) {
+#ifdef HAVE_PQXX
+  try {
+    std::string connection_string =
+        "host=" + host + " port=" + std::to_string(port) + " dbname=" + dbname +
+        " user=" + user + " password=" + password;
+
+    connection_ = std::make_unique<pqxx::connection>(connection_string);
+
+    // The pqxx::connection constructor throws on failure, so if we get here,
+    // the connection is open.
+    std::cout << "Connected to database: " << connection_->dbname()
+              << std::endl;
+    return true;
+  } catch (const std::exception &e) {
+    std::cerr << "Database connection error: " << e.what() << std::endl;
+    return false;
+  }
+#else
+  (void)host;
+  (void)port;
+  (void)dbname;
+  (void)user;
+  (void)password;
+  return false;
+#endif
+}
+
+void DatabaseService::disconnect() {
+#ifdef HAVE_PQXX
+  connection_.reset();
+#endif
+}
+
+bool DatabaseService::isConnected() const {
+#ifdef HAVE_PQXX
+  return connection_ && connection_->is_open();
+#else
+  return false;
+#endif
+}
+
+bool DatabaseService::executeQuery(const std::string &query,
+                                   const std::vector<std::string> &params) {
+#ifdef HAVE_PQXX
+  if (!isConnected()) {
+    std::cerr << "Not connected to database" << std::endl;
+    return false;
+  }
+
+  try {
+    pqxx::work txn(*connection_);
+#if defined(__APPLE__)
+    pqxx::params p;
+    for (const auto &param : params) {
+      p.append(param);
+    }
+    txn.exec(query, p);
+#else
+    std::string q = query;
+    for (size_t i = 0; i < params.size(); ++i) {
+      std::string placeholder = "$" + std::to_string(i + 1);
+      size_t pos = q.find(placeholder);
+      if (pos != std::string::npos) {
+        q.replace(pos, placeholder.size(), txn.quote(params[i]));
+      }
+    }
+    txn.exec(q);
+#endif
+    txn.commit();
+    return true;
+  } catch (const std::exception &e) {
+    std::cerr << "Query execution error: " << e.what() << std::endl;
+    return false;
+  }
+#else
+  (void)query;
+  (void)params;
+  std::cerr << "Database support is disabled as libpqxx is not available."
+            << std::endl;
+  return false;
+#endif
+}
+
+std::unique_ptr<pqxx::result>
+DatabaseService::executeSelect(const std::string &query,
+                               const std::vector<std::string> &params) {
+#ifdef HAVE_PQXX
+  if (!isConnected()) {
+    std::cerr << "Not connected to database" << std::endl;
+    return nullptr;
+  }
+
+  try {
+    pqxx::work txn(*connection_);
+#if defined(__APPLE__)
+    pqxx::params p;
+    for (const auto &param : params) {
+      p.append(param);
+    }
+    auto result = txn.exec(query, p);
+    txn.commit();
+    return std::make_unique<pqxx::result>(std::move(result));
+#else
+    std::string q = query;
+    for (size_t i = 0; i < params.size(); ++i) {
+      std::string placeholder = "$" + std::to_string(i + 1);
+      size_t pos = q.find(placeholder);
+      if (pos != std::string::npos) {
+        q.replace(pos, placeholder.size(), txn.quote(params[i]));
+      }
+    }
+    auto result = txn.exec(q);
+    txn.commit();
+    return std::make_unique<pqxx::result>(std::move(result));
+#endif
+  } catch (const std::exception &e) {
+    std::cerr << "Select query error: " << e.what() << std::endl;
+    return nullptr;
+  }
+#else
+  (void)query;
+  (void)params;
+  std::cerr << "Database support is disabled as libpqxx is not available."
+            << std::endl;
+  return nullptr;
+#endif
+}
+
+} // namespace cursor