@bniladridas/cursor 0.1.7

package/include/services/multi_file_service.h

@@ -0,0 +1,93 @@
+#pragma once
+#include <set>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+struct FileMatch {
+  std::string file_path{};
+  std::string relative_path{};
+  std::string content{};
+  size_t size{0};
+  std::string file_type{};
+};
+
+enum class GitStatusFilter {
+  ALL,       // All files
+  TRACKED,   // Only tracked files
+  UNTRACKED, // Only untracked files
+  MODIFIED,  // Only modified files
+  STAGED,    // Only staged files
+  UNSTAGED   // Only unstaged changes
+};
+
+struct MultiFileOptions {
+  std::vector<std::string> include_patterns;
+  std::vector<std::string> exclude_patterns;
+  bool respect_gitignore = true;
+  bool recursive = true;
+  size_t max_files = 100;
+  size_t max_file_size = 1024 * 1024;       // 1MB
+  size_t max_total_size = 10 * 1024 * 1024; // 10MB
+
+  // Advanced Git filtering
+  GitStatusFilter git_filter = GitStatusFilter::ALL;
+  bool only_text_files = false;
+  bool include_hidden_files = false;
+  std::vector<std::string>
+      language_filters; // e.g., "cpp", "python", "javascript"
+};
+
+class MultiFileService {
+public:
+  // Read multiple files based on patterns
+  static std::vector<FileMatch>
+  read_many_files(const std::vector<std::string> &paths,
+                  const MultiFileOptions &options = MultiFileOptions{});
+
+  // Read files from directory with patterns
+  static std::vector<FileMatch>
+  read_directory_files(const std::string &directory,
+                       const MultiFileOptions &options = MultiFileOptions{});
+
+  // Check if file should be included based on patterns
+  static bool should_include_file(const std::string &file_path,
+                                  const MultiFileOptions &options);
+
+  // Get file type from extension
+  static std::string get_file_type(const std::string &file_path);
+
+  // Load gitignore patterns
+  static std::set<std::string>
+  load_gitignore_patterns(const std::string &directory);
+
+  // Check if path matches gitignore patterns
+  static bool matches_gitignore(const std::string &file_path,
+                                const std::set<std::string> &patterns);
+
+  // Format multi-file content for AI
+  static std::string
+  format_multi_file_content(const std::vector<FileMatch> &files,
+                            const std::string &context_description = "");
+
+  // Advanced Git-aware filtering
+  static std::vector<std::string>
+  get_git_status_files(const std::string &directory, GitStatusFilter filter);
+
+  static bool is_text_file(const std::string &file_path);
+  static bool
+  matches_language_filter(const std::string &file_path,
+                          const std::vector<std::string> &language_filters);
+
+  static std::string get_language_from_extension(const std::string &file_path);
+
+private:
+  // Default exclude patterns
+  static std::vector<std::string> get_default_exclude_patterns();
+
+  // Check if file matches pattern (supports glob-like patterns)
+  static bool matches_pattern(const std::string &file_path,
+                              const std::string &pattern);
+};
+} // namespace Services

package/include/services/sandbox_service.h

@@ -0,0 +1,96 @@
+#pragma once
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+struct SandboxConfig {
+  std::string name;
+  std::string image;
+  std::vector<std::string> volumes;
+  std::map<std::string, std::string> environment_vars;
+  std::vector<std::string> allowed_commands;
+  size_t memory_limit_mb = 512;
+  size_t cpu_limit_percent = 50;
+  int timeout_seconds = 300;
+  bool network_access = false;
+  std::string working_directory = "/workspace";
+};
+
+struct SandboxResult {
+  int exit_code;
+  std::string stdout_output;
+  std::string stderr_output;
+  bool timed_out = false;
+  double execution_time_seconds = 0.0;
+  std::string error_message;
+};
+
+class SandboxService {
+private:
+  static std::map<std::string, SandboxConfig> sandbox_configs_;
+  static std::string get_sandbox_config_path();
+  static void ensure_sandbox_directory();
+  static void initialize_default_configs();
+  static std::string generate_container_name();
+  static bool is_docker_available();
+  static std::string escape_shell_arg(const std::string &arg);
+
+public:
+  // Sandbox management
+  static void initialize();
+  static bool create_sandbox_config(const std::string &name,
+                                    const SandboxConfig &config);
+  static bool remove_sandbox_config(const std::string &name);
+  static std::vector<std::string> list_sandbox_configs();
+  static SandboxConfig get_sandbox_config(const std::string &name);
+
+  // Command execution
+  static SandboxResult
+  execute_command(const std::string &command,
+                  const std::string &sandbox_name = "default",
+                  const std::string &working_dir = "");
+  static SandboxResult
+  execute_script(const std::string &script_content,
+                 const std::string &script_type,
+                 const std::string &sandbox_name = "default");
+  static SandboxResult
+  execute_file(const std::string &file_path,
+               const std::string &sandbox_name = "default");
+
+  // File operations
+  static bool copy_file_to_sandbox(const std::string &host_path,
+                                   const std::string &container_path,
+                                   const std::string &container_name);
+  static bool copy_file_from_sandbox(const std::string &container_path,
+                                     const std::string &host_path,
+                                     const std::string &container_name);
+
+  // Container management
+  static std::vector<std::string> list_active_containers();
+  static bool stop_container(const std::string &container_name);
+  static bool remove_container(const std::string &container_name);
+  static void cleanup_old_containers();
+
+  // Security validation
+  static bool is_command_safe(const std::string &command);
+  static bool validate_sandbox_config(const SandboxConfig &config,
+                                      std::string &error_message);
+  static std::vector<std::string>
+  get_security_warnings(const std::string &command);
+
+  // Configuration management
+  static bool save_sandbox_config();
+  static bool load_sandbox_config();
+  static bool update_sandbox_limits(const std::string &name, size_t memory_mb,
+                                    size_t cpu_percent);
+
+  // Utility functions
+  static bool check_docker_installation();
+  static std::string get_docker_version();
+  static bool pull_docker_image(const std::string &image);
+  static std::vector<std::string> list_available_images();
+};
+} // namespace Services

package/include/services/theme_service.h

@@ -0,0 +1,67 @@
+#pragma once
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Services {
+
+enum class ThemeColor {
+  PRIMARY,
+  SECONDARY,
+  SUCCESS,
+  WARNING,
+  ERROR,
+  INFO,
+  TEXT,
+  BACKGROUND,
+  ACCENT,
+  MUTED
+};
+
+struct Theme {
+  std::string name;
+  std::string description;
+  std::map<ThemeColor, std::string> colors;
+  bool is_dark_theme = false;
+};
+
+class ThemeService {
+private:
+  static std::string current_theme_name_;
+  static std::map<std::string, Theme> available_themes_;
+  static std::string get_theme_config_path();
+  static void ensure_theme_directory();
+  static void initialize_default_themes();
+  static std::string get_ansi_color_code(const std::string &color);
+
+public:
+  // Theme management
+  static void initialize();
+  static bool set_theme(const std::string &theme_name);
+  static std::string get_current_theme();
+  static std::vector<std::string> list_available_themes();
+  static Theme get_theme_info(const std::string &theme_name);
+
+  // Color utilities
+  static std::string colorize(const std::string &text, ThemeColor color);
+  static std::string colorize_command(const std::string &text);
+  static std::string colorize_success(const std::string &text);
+  static std::string colorize_error(const std::string &text);
+  static std::string colorize_warning(const std::string &text);
+  static std::string colorize_info(const std::string &text);
+  static std::string colorize_accent(const std::string &text);
+
+  // Theme persistence
+  static bool save_theme_config();
+  static bool load_theme_config();
+
+  // Theme creation
+  static bool create_custom_theme(const std::string &name, const Theme &theme);
+  static bool delete_custom_theme(const std::string &name);
+
+  // Utility functions
+  static void print_theme_preview(const std::string &theme_name);
+  static void reset_colors();
+  static bool is_color_supported();
+};
+} // namespace Services

package/include/services/web_service.h

@@ -0,0 +1,52 @@
+#pragma once
+#include <algorithm>
+#include <map>
+#include <string>
+
+// Local case-insensitive comparison function for headers
+struct CaseInsensitiveCompare {
+  bool operator()(const std::string &lhs,
+                  const std::string &rhs) const noexcept {
+    return std::lexicographical_compare(
+        lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
+        [](unsigned char ac, unsigned char bc) {
+          return std::tolower(ac) < std::tolower(bc);
+        });
+  }
+};
+
+using HeaderMap = std::map<std::string, std::string, CaseInsensitiveCompare>;
+
+namespace Services {
+struct WebResponse {
+  int status_code;
+  std::string content;
+  std::string content_type;
+  HeaderMap headers;
+  bool success;
+  std::string error_message;
+};
+
+class WebService {
+private:
+  static std::string get_api_key();
+  static std::string extract_text_content(const std::string &html);
+  static std::string sanitize_content(const std::string &content);
+
+public:
+  // Existing search functionality
+  static std::string search(const std::string &query);
+  static bool is_available();
+
+  // New web fetch capabilities
+  static WebResponse fetch_url(const std::string &url);
+  static std::string fetch_text(const std::string &url);
+  static std::string fetch_json(const std::string &url);
+  static WebResponse fetch_with_headers(const std::string &url,
+                                        const HeaderMap &headers);
+  static WebResponse post_json(const std::string &url,
+                               const std::string &json_body,
+                               const HeaderMap &headers);
+  static bool is_valid_url(const std::string &url);
+};
+} // namespace Services

package/include/utils/config.h

@@ -0,0 +1,68 @@
+#pragma once
+
+// Define DLL export/import macros for Windows
+#if defined(_WIN32) || defined(_WIN64)
+#ifndef CURSOR_API
+#ifdef CURSOR_LIBRARY
+#define CURSOR_API __declspec(dllexport)
+#else
+#define CURSOR_API __declspec(dllimport)
+#endif
+#endif
+
+// Disable warning about STL types in the interface
+#ifndef _HAS_CXX17
+#define _HAS_CXX17 1
+#endif
+
+#ifndef _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+#define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+#endif
+
+#pragma warning(disable                                                        \
+                : 4251) // Disable warning about STL types in the interface
+#pragma warning(                                                               \
+    disable                                                                    \
+    : 4275) // Disable warning about non dll-interface class used as base
+
+// Enable secure CRT functions
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+// Disable min/max macros from windows.h
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#else
+#ifndef CURSOR_API
+#define CURSOR_API __attribute__((visibility("default")))
+#endif
+
+// On non-Windows, we can use visibility attributes for better control
+#ifdef __GNUC__
+#ifndef CURSOR_LOCAL
+#define CURSOR_LOCAL __attribute__((visibility("hidden")))
+#endif
+#else
+#ifndef CURSOR_LOCAL
+#define CURSOR_LOCAL
+#endif
+#endif
+#endif
+
+// Disable exporting of STL templates
+#ifdef _MSC_VER
+#define CURSOR_NO_EXPORT_TEMPLATE template class CURSOR_API
+#else
+#define CURSOR_NO_EXPORT_TEMPLATE extern template class CURSOR_API
+#endif
+
+#include <string>
+
+namespace Utils::Config {
+CURSOR_API void load_environment(const std::string &filename = ".env");
+CURSOR_API std::string get_env_var(const std::string &key,
+                                      const std::string &default_value = "");
+CURSOR_API bool has_env_var(const std::string &key);
+} // namespace Utils::Config

package/include/utils/memory_utils.h

@@ -0,0 +1,79 @@
+#pragma once
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace Utils {
+namespace Memory {
+
+// String optimization utilities
+class StringBuilder {
+private:
+  std::string buffer_;
+
+public:
+  explicit StringBuilder(size_t reserve_size = 1024) {
+    buffer_.reserve(reserve_size);
+  }
+
+  StringBuilder &append(const std::string &str) {
+    buffer_.append(str);
+    return *this;
+  }
+
+  StringBuilder &append(char c) {
+    buffer_.push_back(c);
+    return *this;
+  }
+
+  std::string build() { return std::move(buffer_); }
+
+  size_t size() const { return buffer_.size(); }
+
+  const std::string &str() const { return buffer_; }
+  void clear() { buffer_.clear(); }
+  void reserve(size_t size) { buffer_.reserve(size); }
+};
+
+// Efficient string splitting using string_view
+std::vector<std::string_view> split_view(std::string_view input,
+                                         char delimiter);
+std::vector<std::string_view> split_view(std::string_view input,
+                                         std::string_view delimiter);
+
+// Memory usage tracking
+class MemoryTracker {
+private:
+  static size_t current_usage_;
+  static size_t peak_usage_;
+
+public:
+  static void add_allocation(size_t size);
+  static void remove_allocation(size_t size);
+  static size_t get_current_usage() { return current_usage_; }
+  static size_t get_peak_usage() { return peak_usage_; }
+  static void reset_peak() { peak_usage_ = current_usage_; }
+  static std::string format_bytes(size_t bytes);
+};
+
+// RAII memory tracker for automatic tracking
+class ScopedMemoryTracker {
+private:
+  size_t size_;
+
+public:
+  explicit ScopedMemoryTracker(size_t size) : size_(size) {
+    MemoryTracker::add_allocation(size_);
+  }
+
+  ~ScopedMemoryTracker() { MemoryTracker::remove_allocation(size_); }
+
+  // Non-copyable, movable
+  ScopedMemoryTracker(const ScopedMemoryTracker &) = delete;
+  ScopedMemoryTracker &operator=(const ScopedMemoryTracker &) = delete;
+  ScopedMemoryTracker(ScopedMemoryTracker &&) = default;
+  ScopedMemoryTracker &operator=(ScopedMemoryTracker &&) = default;
+};
+
+} // namespace Memory
+} // namespace Utils

package/include/utils/platform.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#ifdef _WIN32
+#include <io.h>
+#include <process.h>
+#include <windows.h>
+#define popen _popen
+#define pclose _pclose
+#define NULL_DEVICE "NUL"
+#define PATH_SEPARATOR "\\"
+#define SHELL_REDIRECT " 2>NUL"
+#define SHELL_REDIRECT_BOTH " >NUL 2>&1"
+#else
+#include <sys/wait.h>
+#include <unistd.h>
+#define NULL_DEVICE "/dev/null"
+#define PATH_SEPARATOR "/"
+#define SHELL_REDIRECT " 2>/dev/null"
+#define SHELL_REDIRECT_BOTH " >/dev/null 2>&1"
+#endif
+
+#include <cstdio>
+#include <string>
+
+namespace Utils {
+namespace Platform {
+
+// Cross-platform command execution
+inline FILE *open_process(const std::string &command, const char *mode) {
+  return popen(command.c_str(), mode);
+}
+
+inline int close_process(FILE *pipe) { return pclose(pipe); }
+
+// Cross-platform null device
+inline std::string get_null_device() { return NULL_DEVICE; }
+
+// Cross-platform path separator
+inline std::string get_path_separator() { return PATH_SEPARATOR; }
+
+// Cross-platform shell redirection
+inline std::string get_shell_redirect() { return SHELL_REDIRECT; }
+
+inline std::string get_shell_redirect_both() { return SHELL_REDIRECT_BOTH; }
+
+// Check if running on Windows
+inline bool is_windows() {
+#ifdef _WIN32
+  return true;
+#else
+  return false;
+#endif
+}
+
+} // namespace Platform
+} // namespace Utils

package/include/utils/ui.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "utils/config.h" // For CURSOR_API
+#include <atomic>
+#include <string>
+
+namespace Utils {
+// Color namespace
+namespace Color {
+extern CURSOR_API const std::string RESET;
+extern CURSOR_API const std::string GREEN;
+extern CURSOR_API const std::string YELLOW;
+extern CURSOR_API const std::string RED;
+extern CURSOR_API const std::string CYAN;
+extern CURSOR_API const std::string BOLD;
+extern CURSOR_API const std::string DIM;
+extern CURSOR_API const std::string PINK;
+} // namespace Color
+
+// UI namespace
+namespace UI {
+// Core functions
+CURSOR_API void print_logo();
+CURSOR_API void print_help();
+CURSOR_API void print_enterprise_status();
+CURSOR_API void spinner(const std::string &message, int duration_ms);
+CURSOR_API void spinner(std::atomic<bool> &done); // For threaded spinner
+
+// Status messages
+CURSOR_API void print_success(const std::string &message);
+CURSOR_API void print_error(const std::string &message);
+CURSOR_API void print_warning(const std::string &message);
+CURSOR_API void print_info(const std::string &message);
+
+// Utility functions
+CURSOR_API void print_divider();
+CURSOR_API void print_quick_help();
+CURSOR_API void print_system_info(const std::string &mode,
+                                     const std::string &model);
+CURSOR_API void print_ready_interface(const std::string &mode,
+                                         const std::string &model);
+CURSOR_API std::string prompt_user(const std::string &prompt_text);
+} // namespace UI
+} // namespace Utils

package/include/utils/validation.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace Utils {
+struct ValidationResult {
+  bool is_valid;
+  std::string error_message;
+  std::vector<std::string> warnings;
+};
+
+class Validator {
+public:
+  // File path validation
+  static ValidationResult
+  validate_file_path(const std::string &path,
+                     const std::string &base_directory = "");
+  static ValidationResult validate_file_exists(const std::string &path);
+  static ValidationResult validate_file_writable(const std::string &path);
+
+  // Text validation
+  static ValidationResult
+  validate_non_empty(const std::string &text,
+                     const std::string &field_name = "text");
+  static ValidationResult validate_regex_pattern(const std::string &pattern);
+
+  // Command validation
+  static ValidationResult validate_command_safe(const std::string &command);
+  static ValidationResult validate_search_query(const std::string &query);
+
+  // Parameter validation
+  static ValidationResult validate_line_range(int start_line, int line_count,
+                                              int total_lines);
+  static ValidationResult validate_replacement_count(int expected, int actual);
+
+  // Composite validation
+  static ValidationResult
+  combine_results(const std::vector<ValidationResult> &results);
+
+  // Utility functions
+  static bool is_safe_path(const std::string &path);
+  static bool is_text_file_extension(const std::string &extension);
+  static const std::vector<std::string> &get_text_extensions();
+  static std::string sanitize_input(const std::string &input);
+};
+
+// Validation helper macros
+#define VALIDATE_AND_RETURN(validation)                                        \
+  do {                                                                         \
+    auto result = validation;                                                  \
+    if (!result.is_valid) {                                                    \
+      return result.error_message;                                             \
+    }                                                                          \
+  } while (0)
+
+#define VALIDATE_PARAM(condition, message)                                     \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      return ValidationResult{false, message, {}};                             \
+    }                                                                          \
+  } while (0)
+} // namespace Utils

package/include/utils/version.h.in

@@ -0,0 +1,17 @@
+#pragma once
+#include <string>
+
+constexpr int cursor_version_major = @PROJECT_VERSION_MAJOR@;
+constexpr int cursor_version_minor = @PROJECT_VERSION_MINOR@;
+constexpr int cursor_version_patch = @PROJECT_VERSION_PATCH@;
+constexpr const char* cursor_version_string = "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@";
+#define CURSOR_BUILD_DATE __DATE__
+#define CURSOR_BUILD_TIME __TIME__
+
+namespace Version {
+    const char* get_version();
+    const char* get_build_info();
+    void print_version_info();
+    std::string check_update();
+    bool download_and_install(const std::string& version);
+}

package/install.js

@@ -0,0 +1,49 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const pkg = require('./package.json');
+const version = pkg.version;
+const binaryDir = path.join(__dirname, 'binary');
+
+const platformMap = {
+  darwin: 'cursor-macos.tar.gz',
+  linux: 'cursor-linux.tar.gz',
+  win32: 'cursor-windows.zip',
+};
+
+const archive = platformMap[process.platform];
+if (!archive) {
+  console.error(`unsupported platform: ${process.platform}`);
+  process.exit(1);
+}
+
+const url = `https://github.com/bniladridas/cursor/releases/download/v${version}/${archive}`;
+
+fs.mkdirSync(binaryDir, { recursive: true });
+
+console.log(`downloading cursor v${version}...`);
+
+const file = fs.createWriteStream(path.join(binaryDir, archive));
+https.get(url, (res) => {
+  if (res.statusCode !== 200) {
+    console.error(`download failed (${res.statusCode}): ${url}`);
+    process.exit(1);
+  }
+  res.pipe(file);
+  file.on('finish', () => {
+    file.close();
+    console.log('extracting...');
+    if (process.platform === 'win32') {
+      execSync(`tar -xf "${path.join(binaryDir, archive)}" -C "${binaryDir}"`, { stdio: 'inherit' });
+    } else {
+      execSync(`tar -xzf "${path.join(binaryDir, archive)}" -C "${binaryDir}"`, { stdio: 'inherit' });
+    }
+    fs.unlinkSync(path.join(binaryDir, archive));
+    console.log('done');
+  });
+}).on('error', (err) => {
+  console.error(`download failed: ${err.message}`);
+  process.exit(1);
+});