@bniladridas/cursor 0.1.7

package/include/services/checkpoint_service.h

@@ -0,0 +1,69 @@
+#pragma once
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Services {
+struct CheckpointInfo {
+  std::string id{};
+  std::string name{};
+  std::string timestamp{};
+  std::string description{};
+  std::vector<std::string> backed_up_files{};
+  size_t total_size{0};
+};
+
+struct RestoreOptions {
+  bool create_backup_before_restore = true;
+  bool restore_memory = true;
+  bool restore_files = true;
+  std::vector<std::string> specific_files; // If empty, restore all
+};
+
+class CheckpointService {
+private:
+  static std::string get_checkpoints_directory();
+  static std::string generate_checkpoint_id();
+  static std::string get_timestamp();
+  static void ensure_checkpoints_directory();
+  static std::vector<std::string>
+  get_project_files(const std::string &directory);
+  static void backup_file(const std::string &source_path,
+                          const std::string &backup_path);
+  static void restore_file(const std::string &backup_path,
+                           const std::string &target_path);
+
+public:
+  // Create checkpoint
+  static std::string create_checkpoint(const std::string &name,
+                                       const std::string &description = "",
+                                       const std::string &directory = ".");
+
+  // List checkpoints
+  static std::vector<CheckpointInfo> list_checkpoints();
+
+  // Get checkpoint info
+  static CheckpointInfo get_checkpoint_info(const std::string &checkpoint_id);
+
+  // Restore from checkpoint
+  static bool
+  restore_checkpoint(const std::string &checkpoint_id,
+                     const RestoreOptions &options = RestoreOptions{});
+
+  // Delete checkpoint
+  static bool delete_checkpoint(const std::string &checkpoint_id);
+
+  // Get checkpoint size
+  static size_t get_checkpoint_size(const std::string &checkpoint_id);
+
+  // Cleanup old checkpoints (keep only N most recent)
+  static void cleanup_old_checkpoints(size_t keep_count = 10);
+
+  // Export checkpoint to archive
+  static bool export_checkpoint(const std::string &checkpoint_id,
+                                const std::string &export_path);
+
+  // Import checkpoint from archive
+  static std::string import_checkpoint(const std::string &archive_path);
+};
+} // namespace Services

package/include/services/codebase_service.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+class CodebaseService {
+public:
+  CodebaseService();
+
+  // Analyze overall codebase structure
+  static std::string analyze_structure(const std::string &path);
+
+  // Find main components and their relationships
+  static std::string find_main_components(const std::string &path);
+
+  // Find TODO/FIXME/HACK comments
+  static std::vector<std::string> find_todos(const std::string &path);
+
+  // Get directory tree structure
+  static std::string get_directory_tree(const std::string &path,
+                                        int max_depth = 3);
+
+private:
+  // Helper methods
+  static void build_tree_recursive(const std::string &path,
+                                   std::ostringstream &tree,
+                                   const std::string &prefix, int depth,
+                                   int max_depth);
+  static std::map<std::string, int> analyze_file_types(const std::string &path);
+  static int count_files_in_directory(const std::string &path);
+  static std::vector<std::string> find_key_files(const std::string &path);
+};
+
+} // namespace Services

package/include/services/command_service.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <array>
+#include <cstdio>
+#include <string>
+
+namespace Services {
+class CommandService {
+private:
+  static const std::array<std::string, 9> dangerous_commands;
+
+  // Check if a command is considered dangerous
+  static bool is_dangerous_command(const std::string &command);
+
+  // Internal method to execute a command and capture its output
+  static std::string execute_command(const std::string &command,
+                                     std::FILE *pipe);
+
+public:
+  // Execute a shell command and return its output
+  // Returns the command output or an error message if execution fails
+  static std::string execute(const std::string &command);
+};
+} // namespace Services

package/include/services/context_service.h

@@ -0,0 +1,74 @@
+#pragma once
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+struct ContextFile {
+  std::string file_path{};
+  std::string content{};
+  int priority{0};      // Higher priority = loaded first
+  std::string source{}; // "global", "project", "local"
+};
+
+class ContextService {
+public:
+  // Load hierarchical context from CURSOR.md files
+  static std::string
+  load_hierarchical_context(const std::string &working_directory = ".");
+
+  // Find all CURSOR.md files in hierarchy
+  static std::vector<ContextFile>
+  find_context_files(const std::string &working_directory = ".");
+
+  // Load global context file
+  static ContextFile load_global_context();
+
+  // Load project context files (from root to current directory)
+  static std::vector<ContextFile>
+  load_project_context(const std::string &working_directory);
+
+  // Load local context files (in current directory and subdirectories)
+  static std::vector<ContextFile>
+  load_local_context(const std::string &working_directory);
+
+  // Merge context files into single string
+  static std::string merge_context_files(const std::vector<ContextFile> &files);
+
+  // Find project root (directory with .git, package.json, CMakeLists.txt, etc.)
+  static std::string
+  find_project_root(const std::string &starting_directory = ".");
+
+  // Check if directory contains project markers
+  static bool is_project_root(const std::string &directory);
+
+  // Refresh context cache
+  static void refresh_context_cache();
+
+  // Get context file template
+  static std::string get_context_template();
+
+  // Create context file in directory
+  static bool create_context_file(const std::string &directory,
+                                  const std::string &content = "");
+
+private:
+  // Cache for loaded context
+  static std::map<std::string, std::string> context_cache;
+  static std::string cached_working_directory;
+
+  // Get home directory
+  static std::string get_home_directory();
+
+  // Check if file exists and is readable
+  static bool is_readable_file(const std::string &file_path);
+
+  // Load file content safely
+  static std::string load_file_content(const std::string &file_path);
+
+  // Get relative path for display
+  static std::string get_display_path(const std::string &file_path,
+                                      const std::string &base_directory);
+};
+} // namespace Services

package/include/services/database_service.h

@@ -0,0 +1,56 @@
+#ifndef DATABASE_SERVICE_H
+#define DATABASE_SERVICE_H
+
+#include <memory>
+#include <string>
+#include <vector>
+#ifdef HAVE_PQXX
+#include <pqxx/pqxx>
+#endif
+
+#ifndef HAVE_PQXX
+namespace pqxx {
+class result {
+public:
+  result() {}
+  size_t size() const { return 0; }
+  // Minimal interface for compatibility
+};
+class connection {
+public:
+  connection(const std::string &) {}
+  bool is_open() const { return false; }
+  std::string dbname() const { return ""; }
+};
+} // namespace pqxx
+#endif
+
+namespace cursor {
+
+class DatabaseService {
+public:
+  DatabaseService();
+  ~DatabaseService();
+
+  bool connect(const std::string &host, int port, const std::string &dbname,
+               const std::string &user, const std::string &password);
+  void disconnect();
+
+  bool isConnected() const;
+
+  // Example methods - extend as needed
+  bool executeQuery(const std::string &query,
+                    const std::vector<std::string> &params = {});
+  std::unique_ptr<pqxx::result>
+  executeSelect(const std::string &query,
+                const std::vector<std::string> &params = {});
+
+private:
+#ifdef HAVE_PQXX
+  std::unique_ptr<pqxx::connection> connection_;
+#endif
+};
+
+} // namespace cursor
+
+#endif // DATABASE_SERVICE_H

package/include/services/error_service.h

@@ -0,0 +1,106 @@
+#pragma once
+#include <chrono>
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+enum class ErrorLevel : std::uint8_t { DEBUG, INFO, WARNING, ERROR, CRITICAL };
+
+enum class ErrorCategory : std::uint8_t {
+  VALIDATION,
+  NETWORK,
+  FILE_SYSTEM,
+  AUTHENTICATION,
+  COMMAND_EXECUTION,
+  MEMORY_MANAGEMENT,
+  CONFIGURATION,
+  UNKNOWN
+};
+
+struct ErrorInfo {
+  std::string id{};
+  ErrorLevel level{ErrorLevel::DEBUG};
+  ErrorCategory category{ErrorCategory::VALIDATION};
+  std::string message{};
+  std::string details{};
+  std::string context{};
+  std::chrono::system_clock::time_point timestamp{};
+  std::vector<std::string> suggestions{};
+  std::map<std::string, std::string> metadata{};
+};
+
+struct ValidationRule {
+  std::string name{};
+  std::function<bool(const std::string &)> validator{};
+  std::string error_message{};
+  std::vector<std::string> suggestions{};
+};
+
+class ErrorService {
+private:
+  static std::vector<ErrorInfo> error_log;
+  static std::map<std::string, ValidationRule> validation_rules;
+  static std::string get_error_log_path();
+  static void ensure_error_directory();
+  static std::string generate_error_id();
+  static void initialize_validation_rules();
+
+public:
+  // Error logging and management
+  static void initialize();
+  static std::string
+  log_error(ErrorLevel level, ErrorCategory category,
+            const std::string &message, const std::string &context = "",
+            const std::vector<std::string> &suggestions = {});
+  static std::vector<ErrorInfo> get_recent_errors(size_t count = 10);
+  static std::vector<ErrorInfo> get_errors_by_level(ErrorLevel level);
+  static std::vector<ErrorInfo> get_errors_by_category(ErrorCategory category);
+  static void clear_error_log();
+
+  // Validation framework
+  static bool validate_input(const std::string &rule_name,
+                             const std::string &input,
+                             std::string &error_message,
+                             std::vector<std::string> &suggestions);
+  static bool validate_file_path(const std::string &path,
+                                 std::string &error_message);
+  static bool validate_url(const std::string &url, std::string &error_message);
+  static bool validate_command(const std::string &command,
+                               std::string &error_message);
+  static bool validate_api_key(const std::string &api_key,
+                               std::string &error_message);
+  static bool validate_json(const std::string &json_str,
+                            std::string &error_message);
+
+  // Error recovery
+  static std::vector<std::string>
+  suggest_recovery_actions(const std::string &error_id);
+  static bool attempt_auto_recovery(const std::string &error_id);
+  static void
+  register_recovery_handler(ErrorCategory category,
+                            std::function<bool(const ErrorInfo &)> handler);
+
+  // Error reporting and formatting
+  static std::string format_error(const ErrorInfo &error,
+                                  bool include_suggestions = true);
+  static std::string format_error_summary();
+  static void print_error_report();
+  static bool export_error_log(const std::string &export_path);
+
+  // Utility functions
+  static std::string error_level_to_string(ErrorLevel level);
+  static std::string error_category_to_string(ErrorCategory category);
+  static ErrorLevel string_to_error_level(const std::string &level_str);
+  static ErrorCategory
+  string_to_error_category(const std::string &category_str);
+
+  // Configuration
+  static void set_max_log_entries(size_t max_entries);
+  static void set_log_level(ErrorLevel min_level);
+  static bool save_error_config();
+  static bool load_error_config();
+};
+} // namespace Services

package/include/services/file_service.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <string>
+#include <vector>
+
+namespace Services {
+struct FileSearchResult {
+  std::string file_path{};
+  int line_number{0};
+  std::string line_content{};
+  std::string match_context{};
+};
+
+struct FileEditResult {
+  bool success{};
+  std::string message{};
+  int replacements_made{0};
+};
+
+class FileService {
+public:
+  // Basic file operations
+  static std::string read_file(const std::string &filename);
+  static std::string read_file_range(const std::string &filename,
+                                     int start_line = 0, int line_count = -1);
+  static std::string write_file(const std::string &filename,
+                                const std::string &content);
+  static bool file_exists(const std::string &filename);
+  static std::string get_file_extension(const std::string &filename);
+
+  // Advanced file operations
+  static FileEditResult replace_text_in_file(const std::string &filename,
+                                             const std::string &old_text,
+                                             const std::string &new_text,
+                                             int expected_replacements = 1);
+  static std::vector<FileSearchResult>
+  search_in_file(const std::string &filename, const std::string &pattern,
+                 bool case_sensitive = false);
+  static std::vector<FileSearchResult>
+  search_in_directory(const std::string &directory, const std::string &pattern,
+                      const std::string &file_filter = "*",
+                      bool case_sensitive = false);
+
+  // Utility functions
+  [[nodiscard]] static bool is_text_file(const std::string &filename);
+  static std::string get_relative_path(const std::string &filepath,
+                                       const std::string &base_path);
+  static bool is_within_directory(const std::string &filepath,
+                                  const std::string &base_directory);
+  static std::string normalize_path(const std::string &path);
+};
+} // namespace Services

package/include/services/git_service.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace Services {
+
+class GitService {
+public:
+  GitService();
+
+  // Check if directory is a git repository
+  static bool is_git_repository(const std::string &path);
+
+  // Get git log for specified number of days
+  static std::string get_git_log(const std::string &path, int days = 7);
+
+  // Get git status
+  static std::string get_git_status(const std::string &path);
+
+  // Get list of files changed in last N days
+  static std::vector<std::string> get_changed_files(const std::string &path,
+                                                    int days = 7);
+
+  // Analyze repository structure and recent activity
+  static std::string analyze_repository(const std::string &path);
+};
+
+} // namespace Services

package/include/services/github_service.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include "services/web_service.h"
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+struct GitHubIssue {
+  int number{0};
+  std::string title{};
+  std::string body{};
+  std::string state{};
+  std::vector<std::string> labels{};
+  std::vector<std::string> assignees{};
+  int milestone{0};
+};
+
+struct GitHubPR {
+  int number{0};
+  std::string title{};
+  std::string body{};
+  std::string state{};
+  std::string head_branch{};
+  std::string base_branch{};
+  bool mergeable{false};
+};
+
+class GitHubService {
+private:
+  static std::string get_github_token();
+  static std::string get_api_base_url();
+  static WebResponse make_github_request(const std::string &endpoint,
+                                         const std::string &method = "GET",
+                                         const std::string &body = "");
+
+public:
+  GitHubService() = delete;
+
+  static std::string get_repo_info(const std::string &owner,
+                                   const std::string &repo);
+  static std::vector<GitHubIssue> get_issues(const std::string &owner,
+                                             const std::string &repo,
+                                             const std::string &state = "open");
+  static GitHubIssue create_issue(const std::string &owner,
+                                  const std::string &repo,
+                                  const std::string &title,
+                                  const std::string &body,
+                                  const std::vector<std::string> &labels = {});
+  static bool update_issue(const std::string &owner, const std::string &repo,
+                           int issue_number,
+                           const std::map<std::string, std::string> &updates);
+  static bool add_comment(const std::string &owner, const std::string &repo,
+                          int issue_number, const std::string &comment);
+  static std::vector<GitHubPR>
+  get_pull_requests(const std::string &owner, const std::string &repo,
+                    const std::string &state = "open");
+  static GitHubPR get_pull_request(const std::string &owner,
+                                   const std::string &repo, int pr_number);
+  static bool create_pr_comment(const std::string &owner,
+                                const std::string &repo, int pr_number,
+                                const std::string &comment);
+  static std::vector<std::string> get_milestones(const std::string &owner,
+                                                 const std::string &repo);
+  static int create_milestone(const std::string &owner, const std::string &repo,
+                              const std::string &title,
+                              const std::string &description = "");
+  static std::vector<std::string> get_labels(const std::string &owner,
+                                             const std::string &repo);
+  static bool create_label(const std::string &owner, const std::string &repo,
+                           const std::string &name, const std::string &color,
+                           const std::string &description = "");
+  static bool create_webhook(const std::string &owner, const std::string &repo,
+                             const std::string &url,
+                             const std::vector<std::string> &events);
+  static std::string run_health_check(const std::string &owner,
+                                      const std::string &repo);
+  static std::string find_related_issues(const std::string &owner,
+                                         const std::string &repo,
+                                         const std::string &text);
+  static bool is_available();
+};
+
+} // namespace Services

package/include/services/mcp_service.h

@@ -0,0 +1,85 @@
+#pragma once
+#include <map>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+struct MCPResource {
+  std::string uri{};
+  std::string name{};
+  std::string description{};
+  std::string mime_type{};
+  nlohmann::json metadata{};
+};
+
+struct MCPTool {
+  std::string name{};
+  std::string description{};
+  nlohmann::json input_schema{};
+};
+
+struct MCPPrompt {
+  std::string name{};
+  std::string description{};
+  std::vector<std::string> arguments{};
+};
+
+struct MCPServer {
+  std::string name{};
+  std::string executable{};
+  std::vector<std::string> args{};
+  std::string working_directory{};
+  std::map<std::string, std::string> env_vars{};
+  bool is_running = false;
+  int process_id = -1;
+};
+
+class MCPService {
+private:
+  static std::map<std::string, MCPServer> servers;
+  static std::string get_mcp_config_path();
+  static void ensure_mcp_directory();
+  static nlohmann::json send_mcp_request(const std::string &server_name,
+                                         const nlohmann::json &request);
+  static bool start_mcp_server(const std::string &server_name);
+  static bool stop_mcp_server(const std::string &server_name);
+  static nlohmann::json
+  create_mcp_request(const std::string &method,
+                     const nlohmann::json &params = nlohmann::json::object());
+
+public:
+  // Server management
+  static bool register_mcp_server(const MCPServer &server);
+  static bool unregister_mcp_server(const std::string &server_name);
+  static std::vector<std::string> list_mcp_servers();
+  static MCPServer get_mcp_server(const std::string &server_name);
+  static bool is_server_running(const std::string &server_name);
+
+  // MCP Protocol operations
+  static std::vector<MCPResource>
+  list_resources(const std::string &server_name);
+  static std::string read_resource(const std::string &server_name,
+                                   const std::string &uri);
+  static std::vector<MCPTool> list_tools(const std::string &server_name);
+  static nlohmann::json call_tool(const std::string &server_name,
+                                  const std::string &tool_name,
+                                  const nlohmann::json &arguments);
+  static std::vector<MCPPrompt> list_prompts(const std::string &server_name);
+  static std::string get_prompt(const std::string &server_name,
+                                const std::string &prompt_name,
+                                const nlohmann::json &arguments);
+
+  // Configuration management
+  static bool load_server_config();
+  static bool save_server_config();
+  static void add_default_servers();
+
+  // Utility functions
+  static bool ping_server(const std::string &server_name);
+  static std::string get_server_status(const std::string &server_name);
+  static void cleanup_dead_servers();
+};
+} // namespace Services