@bniladridas/cursor 0.1.18 → 0.1.19

package/src/main.cpp

@@ -62,7 +62,10 @@ int main(int argc, char *argv[]) {
     Utils::Config::load_environment();
     Utils::UI::print_logo();
 
-    std::string latest = Version::check_update();
+    std::string latest;
+    if (!Utils::Config::has_env_var("CURSOR_SKIP_UPDATE_CHECK")) {
+      latest = Version::check_update();
+    }
     if (!latest.empty()) {
       std::cout << Utils::Color::YELLOW
                 << "Update available: v" << Version::get_version() << " -> v"

package/src/services/ai_service.cpp

@@ -166,34 +166,18 @@ nlohmann::json AIService::create_payload(const std::string &user_input,
     return create_standard_payload("deepseek-chat", user_input, system_prompt);
   case Core::AgentMode::MODE_OPENAI: // OpenAI
     return create_standard_payload("gpt-4", user_input, system_prompt);
-  case Core::AgentMode::MODE_LLAMA_3B: // Llama 3B (local)
-    return {{"model", "llama3.2:3b"},
-            {"stream", false},
-            {"messages",
-             {{{"role", "system"}, {"content", system_prompt}},
-              {{"role", "user"}, {"content", user_input}}}}};
-
-  case Core::AgentMode::MODE_LLAMA_LATEST: // Llama latest (local)
-    return {{"model", "llama3.2:latest"},
-            {"stream", false},
-            {"messages",
-             {{{"role", "system"}, {"content", system_prompt}},
-              {{"role", "user"}, {"content", user_input}}}}};
-
-  case Core::AgentMode::MODE_LLAMA_31: // Llama 3.1 (local)
-    return {{"model", "llama3.1:latest"},
-            {"stream", false},
-            {"messages",
-             {{{"role", "system"}, {"content", system_prompt}},
-              {{"role", "user"}, {"content", user_input}}}}};
-
-  default: // Fallback to Llama 3B
-    return {{"model", "llama3.2:3b"},
+  case Core::AgentMode::MODE_LLAMA_3B: // Local Ollama models
+  case Core::AgentMode::MODE_LLAMA_LATEST:
+  case Core::AgentMode::MODE_LLAMA_31:
+  default: {
+    std::string model = model_name_.empty() ? "llama3.2:3b" : model_name_;
+    return {{"model", model},
             {"stream", false},
             {"messages",
              {{{"role", "system"}, {"content", system_prompt}},
               {{"role", "user"}, {"content", user_input}}}}};
   }
+  }
 }
 
 std::string AIService::parse_cerebras_stream(const std::string &response) {

package/src/services/git_service.cpp

@@ -2,6 +2,7 @@
 #include "utils/platform.h"
 #include "utils/validation.h"
 #include <filesystem>
+#include <unordered_set>
 #include <fstream>
 #include <regex>
 #include <sstream>
@@ -67,6 +68,50 @@ std::string GitService::get_git_status(const std::string &path) {
   return result.empty() ? "Working directory clean" : result;
 }
 
+std::vector<std::string>
+GitService::get_working_tree_changed_files(const std::string &path) {
+  std::vector<std::string> files;
+
+  if (!is_git_repository(path)) {
+    return files;
+  }
+
+  auto collect_files = [&](const std::string &command) {
+    FILE *pipe = Utils::Platform::open_process(command, "r");
+    if (!pipe) {
+      return;
+    }
+
+    char buffer[256];
+    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
+      std::string file(buffer);
+      if (!file.empty() && file.back() == '\n') {
+        file.pop_back();
+      }
+      if (!file.empty()) {
+        files.push_back(file);
+      }
+    }
+    Utils::Platform::close_process(pipe);
+  };
+
+  std::string base = "cd \"" + path + "\" && ";
+  collect_files(base + "git diff --name-only --cached");
+  collect_files(base + "git diff --name-only");
+  collect_files(base + "git ls-files --others --exclude-standard");
+
+  std::vector<std::string> unique_files;
+  std::unordered_set<std::string> seen;
+  for (const auto &file : files) {
+    if (!seen.count(file)) {
+      seen.insert(file);
+      unique_files.push_back(file);
+    }
+  }
+
+  return unique_files;
+}
+
 std::vector<std::string> GitService::get_changed_files(const std::string &path,
                                                        int days) {
   std::vector<std::string> files;
@@ -87,7 +132,6 @@ std::vector<std::string> GitService::get_changed_files(const std::string &path,
   char buffer[256];
   while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
     std::string file(buffer);
-    // Remove newline
     if (!file.empty() && file.back() == '\n') {
       file.pop_back();
     }

package/src/services/web_service.cpp

@@ -155,9 +155,13 @@ bool WebService::is_valid_url(const std::string &url) {
   if (url.find("http://") == 0 || url.find("https://") == 0) {
     // Must have at least a domain after protocol
     size_t domain_start = url.find("://") + 3;
-    if (domain_start < url.length() &&
-        url.find('.', domain_start) != std::string::npos) {
-      return true;
+    if (domain_start < url.length()) {
+      std::string domain = url.substr(domain_start);
+      // Allow localhost without dot
+      if (domain.starts_with("localhost") || domain.starts_with("127.") ||
+          url.find('.', domain_start) != std::string::npos) {
+        return true;
+      }
     }
   }
   return false;

package/src/utils/ui.cpp

@@ -4,6 +4,12 @@
 #include <iostream>
 #include <string>
 #include <thread>
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/ioctl.h>
+#include <unistd.h>
+#endif
 
 namespace Utils {
 
@@ -286,22 +292,102 @@ void UI::print_system_info(const std::string &mode, const std::string &model) {
 // ===== 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";
+  std::cout << Color::DIM << "[" << mode << " | " << model << "]" << Color::RESET << "\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;
 }
 
+// ===== Terminal Management =====
+int UI::get_terminal_width() {
+#ifndef _WIN32
+  struct winsize w;
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0 && w.ws_col > 0)
+    return w.ws_col;
+#endif
+  return 80;
+}
+
+int UI::get_terminal_height() {
+#ifndef _WIN32
+  struct winsize w;
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0 && w.ws_row > 0)
+    return w.ws_row;
+#endif
+  return 24;
+}
+
+void UI::clear_screen() {
+  std::cout << "\033[2J\033[H";
+}
+
+void UI::enter_chat_mode() {
+  clear_screen();
+}
+
+void UI::exit_chat_mode() {
+  std::cout << "\033[?25h";
+}
+
+void UI::clear_line() {
+  std::cout << "\033[2K\r";
+}
+
+void UI::cursor_to(int line, int col) {
+  std::cout << "\033[" << line << ";" << col << "H";
+}
+
+void UI::draw_status_line(const std::string &mode,
+                          const std::string &model,
+                          const std::string &dir) {
+  cursor_to(1, 1);
+  clear_line();
+  std::cout << Color::DIM << "* " << Color::RESET
+            << mode << "    "
+            << Color::BOLD << model << Color::RESET
+            << "    " << Color::DIM << dir << Color::RESET;
+  std::cout.flush();
+}
+
+void UI::draw_context_line(const std::string &hints) {
+  int h = get_terminal_height();
+  cursor_to(h - 2, 1);
+  clear_line();
+  if (!hints.empty()) {
+    std::cout << Color::DIM << hints << Color::RESET;
+  }
+  std::cout.flush();
+}
+
+void UI::draw_input_bar(const std::string &text, int cursor_pos) {
+  int h = get_terminal_height();
+  cursor_to(h - 1, 1);
+  clear_line();
+  std::cout << Color::CYAN << "> " << Color::RESET;
+  if (text.empty()) {
+    std::cout << Color::DIM << "Ask anything..." << Color::RESET;
+    cursor_to(h - 1, 3);
+  } else {
+    std::cout << text;
+    int pos = (cursor_pos < 0) ? (int)text.size() : cursor_pos;
+    cursor_to(h - 1, 3 + pos);
+  }
+  std::cout.flush();
+}
+
+void UI::enable_mouse() {
+  std::cout << "\033[?1000h\033[?1006h";
+  std::cout.flush();
+}
+
+void UI::disable_mouse() {
+  std::cout << "\033[?1006l\033[?1000l";
+  std::cout.flush();
+}
+
 } // namespace Utils

package/src/utils/version.cpp

@@ -22,13 +22,13 @@ size_t write_to_file(void *ptr, size_t size, size_t nmemb, void *userdata) {
   return fwrite(ptr, size, nmemb, file);
 }
 
-std::string get_platform_binary_name() {
+std::pair<std::string, std::string> get_release_asset_names(const std::string &version) {
 #ifdef _WIN32
-  return "cursor-windows.exe";
+  return {"cursor_v" + version + "_windows_amd64.zip", "cursor-windows.exe"};
 #elif defined(__APPLE__)
-  return "cursor-macos";
+  return {"cursor_v" + version + "_darwin_arm64.tar.gz", "cursor-macos"};
 #else
-  return "cursor-linux";
+  return {"cursor_v" + version + "_linux_amd64.tar.gz", "cursor-linux"};
 #endif
 }
 
@@ -103,14 +103,15 @@ std::string check_update() {
 }
 
 bool download_and_install(const std::string &version) {
-  std::string binary_name = get_platform_binary_name();
+  auto [archive, binary_name] = get_release_asset_names(version);
   std::string url =
-      "https://github.com/bniladridas/cursor/releases/download/" + version +
-      "/" + binary_name;
+      "https://github.com/bniladridas/cursor/releases/download/v" + version +
+      "/" + archive;
 
   std::string tmp = "/tmp/cursor-update-" + version;
+  std::string tmpDir = "/tmp/cursor-update-extract-" + version;
 #ifdef _WIN32
-  tmp += ".exe";
+  tmp += ".zip";
 #endif
 
   std::cout << "Downloading v" << version << "...\n";
@@ -139,12 +140,6 @@ bool download_and_install(const std::string &version) {
     return false;
   }
 
-  std::filesystem::permissions(tmp,
-                               std::filesystem::perms::owner_exec |
-                                   std::filesystem::perms::owner_read |
-                                   std::filesystem::perms::owner_write,
-                               std::filesystem::perm_options::add);
-
   std::string exe = get_exe_path();
   if (exe.empty()) {
     std::cerr << "Downloaded to: " << tmp << "\nManually replace binary.\n";
@@ -160,14 +155,52 @@ bool download_and_install(const std::string &version) {
     return false;
   }
 
-  std::filesystem::rename(tmp, exe, ec);
+  std::filesystem::create_directories(tmpDir, ec);
+  if (ec) {
+    std::cerr << "Failed to create extract dir: " << ec.message() << "\n";
+    std::filesystem::rename(backup, exe);
+    std::filesystem::remove(tmp);
+    return false;
+  }
+
+  {
+#ifdef _WIN32
+    std::string cmd =
+        "powershell -NoProfile -Command \"Expand-Archive -LiteralPath '" +
+        tmp + "' -DestinationPath '" + tmpDir + "' -Force\"";
+#else
+    std::string cmd = "tar -xzf \"" + tmp + "\" -C \"" + tmpDir + "\"";
+#endif
+    int rc = std::system(cmd.c_str());
+    if (rc != 0) {
+      std::cerr << "Extract failed\n";
+      std::filesystem::rename(backup, exe);
+      std::filesystem::remove(tmp);
+      std::filesystem::remove_all(tmpDir);
+      return false;
+    }
+  }
+
+  std::string extracted = tmpDir + "/" + binary_name;
+  if (!std::filesystem::exists(extracted)) {
+    std::cerr << "Extracted binary not found: " << extracted << "\n";
+    std::filesystem::rename(backup, exe);
+    std::filesystem::remove(tmp);
+    std::filesystem::remove_all(tmpDir);
+    return false;
+  }
+
+  std::filesystem::rename(extracted, exe, ec);
   if (ec) {
     std::cerr << "Failed to install: " << ec.message() << "\n";
     std::filesystem::rename(backup, exe);
     std::filesystem::remove(tmp);
+    std::filesystem::remove_all(tmpDir);
     return false;
   }
 
+  std::filesystem::remove(tmp);
+  std::filesystem::remove_all(tmpDir);
   std::cout << "Updated to v" << version << " successfully!\n";
   return true;
 }

package/tests/e2e/run_local_batch.sh

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+repo_root="$(cd "$script_dir/../.." && pwd)"
+
+binary_path="${BINARY_PATH:-${1:-}}"
+if [[ -z "$binary_path" ]]; then
+  for candidate in \
+    "$repo_root/build/bin/cursor-agent" \
+    "$repo_root/build/bin/Release/cursor-agent.exe" \
+    "$repo_root/build/bin/cursor-agent.exe"; do
+    if [[ -x "$candidate" ]]; then
+      binary_path="$candidate"
+      break
+    fi
+  done
+fi
+
+if [[ -z "$binary_path" ]]; then
+  echo "Usage: BINARY_PATH=/path/to/cursor-agent $0 [binary-path]" >&2
+  echo "Could not find a built cursor-agent under $repo_root/build/bin." >&2
+  exit 2
+fi
+
+if [[ ! -x "$binary_path" ]]; then
+  echo "Binary is not executable: $binary_path" >&2
+  exit 2
+fi
+binary_path="$(cd "$(dirname "$binary_path")" && pwd)/$(basename "$binary_path")"
+
+workdir="$(mktemp -d)"
+mkdir -p "$workdir/home"
+cleanup() {
+  rm -rf "$workdir"
+}
+trap cleanup EXIT
+
+input_file="$workdir/input.txt"
+output_file="$workdir/output.txt"
+
+cat >"$input_file" <<'EOF'
+help
+version
+write:e2e.txt alpha beta
+read:e2e.txt
+replace:e2e.txt:alpha:omega:1
+read:e2e.txt
+grep:omega:.:e2e.txt
+remember:e2e-memory-fact
+memory
+clear
+cmd:echo e2e-cmd-ok
+!echo e2e-bang-ok
+!
+echo e2e-shell-mode-ok
+!
+/help
+/stats
+exit
+EOF
+
+set +e
+bash -c 'cd "$1" && HOME="$1/home" CURSOR_SKIP_UPDATE_CHECK=1 "$2" <"$3" >"$4" 2>&1' bash "$workdir" "$binary_path" "$input_file" "$output_file" &
+agent_pid=$!
+deadline=$((SECONDS + 20))
+while kill -0 "$agent_pid" 2>/dev/null; do
+  if ((SECONDS >= deadline)); then
+    kill "$agent_pid" 2>/dev/null || true
+    wait "$agent_pid" 2>/dev/null
+    run_status=124
+    break
+  fi
+  sleep 1
+done
+if [[ -z "${run_status:-}" ]]; then
+  wait "$agent_pid"
+  run_status=$?
+fi
+set -e
+if [[ $run_status -ne 0 ]]; then
+  echo "Agent batch run failed with exit code $run_status" >&2
+  echo "=== Full output ===" >&2
+  cat "$output_file" >&2 || true
+  exit 1
+fi
+
+assert_contains() {
+  local expected="$1"
+  if ! grep -Fq "$expected" "$output_file"; then
+    echo "Missing expected output: $expected" >&2
+    echo "=== Full output ===" >&2
+    cat "$output_file" >&2
+    exit 1
+  fi
+}
+
+assert_not_contains() {
+  local unexpected="$1"
+  if grep -Fq "$unexpected" "$output_file"; then
+    echo "Unexpected output found: $unexpected" >&2
+    echo "=== Full output ===" >&2
+    cat "$output_file" >&2
+    exit 1
+  fi
+}
+
+assert_contains "Welcome to Cursor"
+assert_contains "Commands"
+assert_contains "Cursor v"
+assert_contains "File 'e2e.txt' written successfully"
+assert_contains "alpha beta"
+assert_contains "Successfully replaced 1 occurrence(s)"
+assert_contains "omega beta"
+assert_contains "Found 1 matches:"
+assert_contains "Remembered: e2e-memory-fact"
+assert_contains "e2e-memory-fact"
+assert_contains "Session memory cleared"
+assert_contains "e2e-cmd-ok"
+assert_contains "e2e-bang-ok"
+assert_contains "Entering shell mode"
+assert_contains "e2e-shell-mode-ok"
+assert_contains "Exiting shell mode"
+assert_contains "Available meta commands:"
+assert_contains "Session Statistics:"
+assert_contains "Goodbye"
+assert_contains "Agent run completed"
+assert_not_contains "AI service returned status code"
+assert_not_contains "AI service unavailable"
+
+echo "Local batch E2E passed"

package/tests/main_test.cpp

@@ -1,15 +1,178 @@
+#include "services/ai_service.h"
+#include "memory_manager.h"
+#include "agent.h"
 #include "version.h"
 #include <gtest/gtest.h>
+#include <functional>
+#include <iostream>
+#include <sstream>
+
+static std::string capture_stdout(const std::function<void()> &fn) {
+  std::ostringstream buffer;
+  std::streambuf *old_buf = std::cout.rdbuf(buffer.rdbuf());
+  fn();
+  std::cout.rdbuf(old_buf);
+  return buffer.str();
+}
 
 // Basic test to verify the testing framework works
 TEST(BasicTest, SanityCheck) { EXPECT_EQ(1 + 1, 2); }
 
+TEST(AgentTest, DirectCommandRouting) {
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("cmd:ls"));
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("build:make"));
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("grep:main:src"));
+  EXPECT_FALSE(Core::Agent::is_direct_command_input("foo:bar"));
+  EXPECT_FALSE(Core::Agent::is_direct_command_input("abc:def:ghi"));
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("memory"));
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("clear"));
+  EXPECT_TRUE(Core::Agent::is_direct_command_input("forget"));
+  EXPECT_FALSE(Core::Agent::is_direct_command_input("memory show"));
+  EXPECT_FALSE(Core::Agent::is_direct_command_input("clear the build cache"));
+  EXPECT_FALSE(Core::Agent::is_direct_command_input("forget about that error"));
+}
+
+TEST(AgentTest, MapNaturalLanguageToDirectCommands) {
+  EXPECT_TRUE(Core::Agent::map_nl_to_direct_command(
+                  "can you check the files we changed").has_value());
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command(
+                "can you check the files we changed"), "git:status");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command(
+                "show changed files in repo"), "git:status");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command(
+                "what is the commit history"), "git:log");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command(
+                "find TODO in code"), "todos:.");
+}
+
+TEST(AgentTest, MapAllNaturalLanguageToDirectCommands) {
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("run make test"), "cmd:make test");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("build the project"), "build:make");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("read file src/main.cpp"), "read:src/main.cpp");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("save file notes.txt as hello world"), "write:notes.txt hello world");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("remember the api key is secret"), "remember:the api key is secret");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("forget everything"), "forget");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("show memory"), "memory");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("clear memory"), "clear");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("replace foo with bar in file README.md"), "replace:README.md:foo:bar");
+  EXPECT_EQ(*Core::Agent::map_nl_to_direct_command("open owner/repo on github"), "github:repo:owner/repo");
+}
+
+TEST(AgentTest, AgenticWorkflowCommands) {
+  Core::Agent agent;
+  std::string output = capture_stdout([&] {
+    agent.process_user_input("/goal set Fix the issue");
+    agent.process_user_input("/task add Investigate logs");
+    agent.process_user_input("/task list");
+  });
+  EXPECT_NE(output.find("Goal set: Fix the issue"), std::string::npos);
+  EXPECT_NE(output.find("Task added: [1] Investigate logs"), std::string::npos);
+  EXPECT_NE(output.find("Active tasks:"), std::string::npos);
+}
+
+TEST(AgentTest, DebugModeTogglesVerbosePipelineOutput) {
+  Core::Agent agent;
+
+  std::string output = capture_stdout([&] {
+    agent.process_user_input("git status");
+  });
+  EXPECT_EQ(output.find("INPUT RECEIVED"), std::string::npos);
+  EXPECT_EQ(output.find("Input classification"), std::string::npos);
+
+  output = capture_stdout([&] {
+    agent.process_user_input("/debug");
+    agent.process_user_input("git status");
+  });
+  EXPECT_NE(output.find("Verbose mode ON"), std::string::npos);
+  EXPECT_NE(output.find("INPUT RECEIVED"), std::string::npos);
+  EXPECT_NE(output.find("Input classification"), std::string::npos);
+
+  output = capture_stdout([&] {
+    agent.process_user_input("/debug");
+    agent.process_user_input("git status");
+  });
+  EXPECT_NE(output.find("Verbose mode OFF"), std::string::npos);
+  size_t off_pos = output.find("Verbose mode OFF");
+  EXPECT_EQ(output.find("INPUT RECEIVED", off_pos), std::string::npos);
+  EXPECT_EQ(output.find("Input classification", off_pos), std::string::npos);
+}
+
+TEST(AgentTest, DetectGitStatusQuery) {
+  EXPECT_TRUE(Core::Agent::is_git_status_query(
+      "can you check the files we changed"));
+  EXPECT_TRUE(Core::Agent::is_git_status_query("what changed in the repo"));
+  EXPECT_TRUE(Core::Agent::is_git_status_query("show changed files"));
+  EXPECT_FALSE(Core::Agent::is_git_status_query("please help me with a diagram"));
+}
+
+TEST(AgentTest, ShowAgentDocumentation) {
+  Core::Agent agent;
+  std::string output = capture_stdout([&] {
+    agent.show_agent_documentation();
+  });
+
+  EXPECT_NE(output.find("Runtime help from AGENTS.md:"),
+            std::string::npos);
+  EXPECT_NE(output.find("Runtime Help Integration"), std::string::npos);
+}
+
 // Test for version functionality
 TEST(VersionTest, VersionCommand) {
   const char *version = Version::get_version();
   EXPECT_STREQ(version, cursor_version_string);
 }
 
+TEST(AgentTest, FormattedGitStatusOutput) {
+  Core::Agent agent;
+  capture_stdout([&] { agent.process_user_input("/debug"); });
+  std::vector<std::string> empty_files;
+  std::vector<std::string> files = {"src/main.cpp", "include/agent.h", "CMakeLists.txt"};
+
+  // Test with empty files (should show clean status)
+  std::string output = capture_stdout([&] {
+    agent.show_git_status_results(empty_files);
+  });
+  EXPECT_NE(output.find("clean"), std::string::npos);
+
+  // Test with files (should show file list with numbers)
+  output = capture_stdout([&] {
+    agent.show_git_status_results(files);
+  });
+  EXPECT_NE(output.find("src/main.cpp"), std::string::npos);
+  EXPECT_NE(output.find("include/agent.h"), std::string::npos);
+  EXPECT_NE(output.find("CMakeLists.txt"), std::string::npos);
+}
+
+TEST(AgentTest, FormattedFilePreview) {
+  Core::Agent agent;
+  capture_stdout([&] { agent.process_user_input("/debug"); });
+  std::string content = "int main() {\n  std::cout << \"Hello\";\n  return 0;\n}\n";
+
+  // Test file preview with syntax highlighting
+  std::string output = capture_stdout([&] {
+    agent.show_file_preview("test.cpp", content, 10);
+  });
+
+  // Should show filename
+  EXPECT_NE(output.find("test.cpp"), std::string::npos);
+  // Should show content with line numbers
+  EXPECT_NE(output.find("main"), std::string::npos);
+  EXPECT_NE(output.find("Hello"), std::string::npos);
+}
+
+TEST(AgentTest, FormattedFilePreviewHandlesErrors) {
+  Core::Agent agent;
+  capture_stdout([&] { agent.process_user_input("/debug"); });
+  std::string error_msg = "Error: File 'nonexistent.txt' does not exist";
+
+  // Test that error messages are displayed
+  std::string output = capture_stdout([&] {
+    agent.show_file_preview("nonexistent.txt", error_msg, 10);
+  });
+
+  EXPECT_NE(output.find("Error:"), std::string::npos);
+}
+
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();