@bniladridas/cursor 0.1.17 → 0.1.19

package/src/agent.cpp

@@ -21,20 +21,44 @@
 #include "version.h"
 
 #include <algorithm>
+#include <optional>
 #include <atomic>
 #include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <iomanip>
 #include <iostream>
 #include <thread>
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#include <termios.h>
+#endif
 
 #include <filesystem>
 #include <fstream>
 #include <map>
+#include <nlohmann/json.hpp>
 #include <sstream>
 #include <vector>
 
 // Constants for response handling
 const size_t MAX_RESPONSE_LENGTH = 8000;
 
+#ifdef CURSOR_USE_LIBEDIT
+extern "C" char *readline(const char *);
+extern "C" void add_history(const char *);
+#endif
+
+static bool is_tty_stream(FILE *stream) {
+#ifdef _WIN32
+  return _isatty(_fileno(stream)) != 0;
+#else
+  return isatty(fileno(stream)) != 0;
+#endif
+}
+
 // Using the Mode enum from agent.h instead of separate constants
 
 namespace Core {
@@ -56,50 +80,513 @@ static inline std::string trim_copy(const std::string &s) {
   return s.substr(a, b - a);
 }
 
+static bool starts_with_at(const std::string &s, size_t pos,
+                           const std::string &prefix) {
+  return pos + prefix.size() <= s.size() &&
+         s.compare(pos, prefix.size(), prefix) == 0;
+}
+
+static std::string normalize_input(const std::string &input) {
+  std::string lower = input;
+  std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+  return lower;
+}
+
+static std::string strip_trailing_clause(std::string input) {
+  std::string lower = normalize_input(input);
+  const std::array<std::string_view, 4> suffixes = {
+      " in code", " in repo", " in this repo", " in project"};
+  for (const auto &suffix : suffixes) {
+    if (lower.ends_with(suffix)) {
+      input = trim_copy(input.substr(0, input.size() - suffix.size()));
+      break;
+    }
+  }
+  return input;
+}
+
+static std::optional<std::string>
+extract_grep_command(const std::string &input, const std::string &marker) {
+  std::string lower = normalize_input(input);
+  size_t pos = lower.find(marker);
+  if (pos == std::string::npos)
+    return std::nullopt;
+
+  std::string query = trim_copy(input.substr(pos + marker.size()));
+  query = strip_trailing_clause(query);
+  if (query.empty())
+    return std::nullopt;
+  return std::make_optional(std::string("grep:") + query);
+}
+
+bool Agent::is_direct_command_input(const std::string &input) {
+  static const std::array<std::string_view, 3> direct_aliases = {
+      "memory", "clear", "forget"};
+  for (const auto &alias : direct_aliases) {
+    if (input == alias) {
+      return true;
+    }
+  }
+
+  static const std::array<std::string_view, 14> direct_prefixes = {
+      "search:", "cmd:",    "build:", "read:",  "write:",
+      "replace:", "grep:",  "remember:", "analyze:", "components:",
+      "todos:",   "git:",   "tree:",  "github:"};
+  for (const auto &prefix : direct_prefixes) {
+    if (input.starts_with(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool Agent::is_git_status_query(const std::string &input) {
+  std::string lower = normalize_input(input);
+
+  static const std::vector<std::string> triggers = {
+      "files we changed",
+      "changed files",
+      "show changed files",
+      "what changed",
+      "check changed files",
+      "check the files we changed",
+      "what files changed",
+      "what changes",
+      "what has changed",
+      "git diff",
+      "git status"};
+
+  for (const auto &phrase : triggers) {
+    if (lower.find(phrase) != std::string::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::optional<std::string> Agent::map_nl_to_direct_command(
+    const std::string &input) {
+  std::string lower = normalize_input(input);
+  // Helper to extract the remainder after a marker
+  auto extract_after = [&](const std::vector<std::string> &markers)
+      -> std::optional<std::string> {
+    for (const auto &m : markers) {
+      size_t pos = lower.find(m);
+      if (pos != std::string::npos) {
+        std::string val = trim_copy(input.substr(pos + m.size()));
+        if (!val.empty())
+          return std::make_optional(val);
+      }
+    }
+    return std::nullopt;
+  };
+
+  // Git-related queries
+  if (is_git_status_query(input) || lower.find("what changed") != std::string::npos) {
+    return std::make_optional(std::string("git:status"));
+  }
+  if (lower.find("git diff") != std::string::npos ||
+      lower.find("show diff") != std::string::npos ||
+      lower.find("diff") != std::string::npos) {
+    return std::make_optional(std::string("git:status"));
+  }
+  if (lower.find("git log") != std::string::npos ||
+      lower.find("commit history") != std::string::npos ||
+      lower.find("recent commits") != std::string::npos) {
+    return std::make_optional(std::string("git:log"));
+  }
+
+  // Run/execute shell commands
+  if (auto cmd = extract_after({"run ", "execute ", "start "})) {
+    return std::make_optional(std::string("cmd:") + *cmd);
+  }
+
+  // Build / compile requests
+  if (lower.find("build the project") != std::string::npos ||
+      lower.find("build project") != std::string::npos ||
+      lower.find("compile") != std::string::npos ||
+      lower.find("build") == 0) {
+    // Prefer explicit make invocation when mentioned, otherwise use build wrapper
+    if (auto make_cmd = extract_after({"make "})) {
+      return std::make_optional(std::string("cmd:") + *make_cmd);
+    }
+    return std::make_optional(std::string("build:make"));
+  }
+
+  // TODO / task comment queries (prefer over grep)
+  if (lower.find("todo") != std::string::npos || lower.find("task comments") != std::string::npos || lower.find("fixme") != std::string::npos) {
+    return std::make_optional(std::string("todos:."));
+  }
+
+  // Grep/search-style queries
+  if (lower.find("search for ") != std::string::npos &&
+      (lower.find("code") != std::string::npos ||
+       lower.find("repo") != std::string::npos ||
+       lower.find("project") != std::string::npos)) {
+    return extract_grep_command(input, "search for ");
+  }
+  if ((lower.find("find ") != std::string::npos &&
+       (lower.find("in code") != std::string::npos ||
+        lower.find("in repo") != std::string::npos ||
+        lower.find("in project") != std::string::npos ||
+        lower.find("in files") != std::string::npos)) ||
+      lower.find("grep ") != std::string::npos) {
+    if (auto g = extract_after({"find ", "grep ", "search for "}))
+      return extract_grep_command(*g, "");
+  }
+
+  // Read/open file
+  if (auto path = extract_after({"read file ", "show file ", "open file "})) {
+    return std::make_optional(std::string("read:") + *path);
+  }
+
+  // Write/save file
+  if (lower.find("save file ") != std::string::npos ||
+      lower.find("write file ") != std::string::npos ||
+      lower.find("save ") == 0) {
+    if (auto p = extract_after({"save file ", "write file ", "save "})) {
+      // If user provided content like "save file X as Y", attempt to parse
+      size_t as_pos = normalize_input(*p).find(" as ");
+      if (as_pos != std::string::npos) {
+        std::string filename = trim_copy(p->substr(0, as_pos));
+        std::string content = trim_copy(p->substr(as_pos + 4));
+        if (!filename.empty() && !content.empty())
+          return std::make_optional(std::string("write:") + filename + " " + content);
+      }
+      // Fallback: just write filename (caller will validate usage)
+      return std::make_optional(std::string("write:") + *p);
+    }
+  }
+
+  // Replace text in files: "replace X with Y in file Z"
+  if (lower.find("replace ") != std::string::npos && lower.find(" with ") != std::string::npos) {
+    // crude parsing
+    size_t rep_pos = lower.find("replace ");
+    size_t with_pos = lower.find(" with ");
+    std::string old_text = trim_copy(input.substr(rep_pos + 8, with_pos - (rep_pos + 8)));
+    size_t in_pos = lower.find(" in file ");
+    if (in_pos == std::string::npos)
+      in_pos = lower.find(" in ");
+    if (in_pos != std::string::npos) {
+      std::string new_text = trim_copy(input.substr(with_pos + 6, in_pos - (with_pos + 6)));
+      std::string filename = trim_copy(input.substr(in_pos + (lower.find(" in file ") != std::string::npos ? 9 : 4)));
+      if (!filename.empty() && !old_text.empty() && !new_text.empty()) {
+        return std::make_optional(std::string("replace:") + filename + ":" + old_text + ":" + new_text);
+      }
+    }
+  }
+
+  // Remember / forget / memory / clear
+  if (auto fact = extract_after({"remember ", "remember:"})) {
+    return std::make_optional(std::string("remember:") + *fact);
+  }
+  if (lower.find("forget") != std::string::npos) {
+    return std::make_optional(std::string("forget"));
+  }
+  if (lower.find("show memory") != std::string::npos || lower.find("memory show") != std::string::npos || lower == "memory") {
+    return std::make_optional(std::string("memory"));
+  }
+  if (lower.find("clear memory") != std::string::npos || lower == "clear") {
+    return std::make_optional(std::string("clear"));
+  }
+
+  // Analyze / components / todos / tree
+  if (lower.find("analyze repo") != std::string::npos || lower.find("analyze") == 0 || lower.find("repository analysis") != std::string::npos) {
+    return std::make_optional(std::string("analyze:."));
+  }
+  if (lower.find("components") != std::string::npos) {
+    return std::make_optional(std::string("components:."));
+  }
+  if (lower.find("todo") != std::string::npos || lower.find("task comments") != std::string::npos) {
+    return std::make_optional(std::string("todos:."));
+  }
+  if (lower.find("directory tree") != std::string::npos || lower.find("repo tree") != std::string::npos || lower.find("tree ") != std::string::npos) {
+    return std::make_optional(std::string("tree:."));
+  }
+
+  // GitHub quick helpers: "open repo owner/repo on github" or "github repo owner/repo"
+  if (lower.find("on github") != std::string::npos) {
+    // try to find owner/repo earlier in the sentence
+    size_t slash = lower.find('/');
+    if (slash != std::string::npos) {
+      // extract token around slash
+      size_t start = lower.rfind(' ', slash);
+      if (start == std::string::npos) start = 0; else start++;
+      size_t end = lower.find(' ', slash);
+      if (end == std::string::npos) end = lower.size();
+      std::string repo_spec = trim_copy(input.substr(start, end - start));
+      return std::make_optional(std::string("github:repo:") + repo_spec);
+    }
+  }
+
+  // Fallback: no mapping
+  return std::nullopt;
+}
+
+static std::string replace_inline_markdown(const std::string &line) {
+  std::string out;
+  bool bold = false;
+  bool code = false;
+  for (size_t i = 0; i < line.size(); i++) {
+    if (starts_with_at(line, i, "**")) {
+      out += bold ? Utils::Color::RESET : Utils::Color::BOLD;
+      bold = !bold;
+      i++;
+    } else if (line[i] == '`') {
+      out += code ? Utils::Color::RESET : Utils::Color::YELLOW;
+      code = !code;
+    } else {
+      out += line[i];
+    }
+  }
+  if (bold || code) {
+    out += Utils::Color::RESET;
+  }
+  return out;
+}
+
+static std::string highlight_code_line(const std::string &line,
+                                       const std::string &language) {
+  std::string out;
+  std::string token;
+  auto flush_token = [&]() {
+    if (token.empty()) {
+      return;
+    }
+    static const std::vector<std::string> keywords = {
+        "auto", "bool", "break", "case", "class", "const", "continue",
+        "else", "false", "for", "function", "if", "int", "let", "return",
+        "std", "string", "struct", "true", "var", "void", "while"};
+    bool is_keyword =
+        std::find(keywords.begin(), keywords.end(), token) != keywords.end();
+    if (is_keyword) {
+      out += Utils::Color::CYAN + token + Utils::Color::RESET;
+    } else {
+      out += token;
+    }
+    token.clear();
+  };
+
+  for (size_t i = 0; i < line.size(); i++) {
+    char ch = line[i];
+    if (language == "html" && (ch == '<' || ch == '>')) {
+      flush_token();
+      out += Utils::Color::CYAN;
+      out += ch;
+      out += Utils::Color::RESET;
+    } else if (ch == '"' || ch == '\'') {
+      flush_token();
+      char quote = ch;
+      out += Utils::Color::YELLOW;
+      out += ch;
+      i++;
+      while (i < line.size()) {
+        out += line[i];
+        if (line[i] == quote) {
+          break;
+        }
+        i++;
+      }
+      out += Utils::Color::RESET;
+    } else if (std::isalnum(static_cast<unsigned char>(ch)) || ch == '_') {
+      token += ch;
+    } else {
+      flush_token();
+      out += ch;
+    }
+  }
+  flush_token();
+  return out;
+}
+
+static std::string render_markdown(const std::string &text) {
+  std::stringstream input(text);
+  std::ostringstream output;
+  std::string line;
+  bool in_code = false;
+  std::string language;
+
+  while (std::getline(input, line)) {
+    std::string trimmed = trim_copy(line);
+    if (trimmed.starts_with("```")) {
+      in_code = !in_code;
+      language = in_code ? trim_copy(trimmed.substr(3)) : "";
+      if (in_code && !language.empty()) {
+        output << Utils::Color::DIM << language << Utils::Color::RESET << "\n";
+      }
+      continue;
+    }
+
+    if (in_code) {
+      output << "  " << highlight_code_line(line, language) << "\n";
+    } else if (trimmed.starts_with("#")) {
+      size_t pos = trimmed.find_first_not_of("# ");
+      output << Utils::Color::BOLD
+             << (pos == std::string::npos ? trimmed : trimmed.substr(pos))
+             << Utils::Color::RESET << "\n";
+    } else {
+      output << replace_inline_markdown(line) << "\n";
+    }
+  }
+  return output.str();
+}
+
+static std::string read_prompt(const std::string &prompt,
+                               const std::vector<std::string> &history) {
+#ifdef CURSOR_USE_LIBEDIT
+  (void)history;
+  char *line = readline(prompt.c_str());
+  if (line == nullptr) {
+    std::cin.setstate(std::ios::eofbit);
+    return {};
+  }
+  std::string input(line);
+  if (!input.empty()) {
+    add_history(line);
+  }
+  std::free(line);
+  return input;
+#else
+#ifdef _WIN32
+  (void)prompt;
+  (void)history;
+  std::string input;
+  if (!std::getline(std::cin, input)) {
+    std::cin.setstate(std::ios::eofbit);
+    return {};
+  }
+  return input;
+#else
+  std::string buf;
+  std::string saved;
+  int cursor = 0;
+  int history_index = (int)history.size();
+  struct termios oldt, newt;
+  tcgetattr(STDIN_FILENO, &oldt);
+  newt = oldt;
+  newt.c_lflag &= ~(ICANON | ECHO);
+  tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+
+  auto redraw = [&]() {
+    Utils::UI::clear_line();
+    std::cout << prompt << buf;
+    std::cout << "\r\033[" << ((int)prompt.size() + cursor) << "C"
+              << std::flush;
+  };
+
+  while (true) {
+    int ch = std::cin.get();
+    if (ch == EOF || ch == '\n' || ch == '\r') {
+      break;
+    }
+    if (ch == 127 || ch == '\b') {
+      if (cursor > 0) {
+        buf.erase(cursor - 1, 1);
+        cursor--;
+        redraw();
+      }
+    } else if (ch == '\033') {
+      if (std::cin.get() == '[') {
+        int c = std::cin.get();
+        if (c == 'A' && history_index > 0) {
+          if (history_index == (int)history.size()) {
+            saved = buf;
+          }
+          history_index--;
+          buf = history[history_index];
+          cursor = (int)buf.size();
+          redraw();
+        } else if (c == 'B' && history_index < (int)history.size()) {
+          history_index++;
+          buf = history_index == (int)history.size() ? saved
+                                                     : history[history_index];
+          cursor = (int)buf.size();
+          redraw();
+        } else if (c == 'D' && cursor > 0) {
+          cursor--;
+          redraw();
+        } else if (c == 'C' && cursor < (int)buf.size()) {
+          cursor++;
+          redraw();
+        }
+      }
+    } else if (ch >= 32 && ch < 127) {
+      buf.insert(cursor, 1, (char)ch);
+      cursor++;
+      redraw();
+    }
+  }
+
+  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+  std::cout << "\n";
+  return buf;
+#endif
+#endif
+}
+
+std::string Agent::format_message(const std::string &sender,
+                                   const std::string &content) {
+  std::string color;
+  if (sender == "Cursor")
+    color = Utils::Color::GREEN;
+  else
+    color = Utils::Color::CYAN;
+  return Utils::Color::GREEN + "| " + Utils::Color::RESET + Utils::Color::BOLD +
+         sender + Utils::Color::RESET + "\n" + color + "| " +
+         Utils::Color::RESET + content;
+}
+
 void Agent::run() {
   initialize_mode();
 
-  // Data-driven model name mapping
-  // Data-driven model name mapping
-  std::map<Agent::Mode, std::string> model_names = {
-      {Agent::Mode::MODE_TOGETHER, "Together AI"},
-      {Agent::Mode::MODE_CEREBRAS, "Cerebras"},
-      {Agent::Mode::MODE_FIREWORKS, "Fireworks"},
-      {Agent::Mode::MODE_GROQ, "Groq"},
-      {Agent::Mode::MODE_DEEPSEEK, "DeepSeek"},
-      {Agent::Mode::MODE_OPENAI, "OpenAI"},
-      {Agent::Mode::MODE_LLAMA_3B, "llama3.2:3b"},
-      {Agent::Mode::MODE_LLAMA_LATEST, "llama3.2:latest"},
-      {Agent::Mode::MODE_LLAMA_31, "llama3.1:latest"}};
-
-  // Show enhanced ready interface with system info and quick help
   std::string mode_name = is_online_mode() ? "Online" : "Offline";
-  std::string model_name =
-      model_names.count(mode_) ? model_names[mode_] : "Unknown";
-  Utils::UI::print_ready_interface(mode_name, model_name);
+  std::string model_name = ollama_model_.empty()
+      ? "local"
+      : ollama_model_;
+  bool tty = is_tty_stream(stdout) && is_tty_stream(stdin);
 
+  if (tty) {
+    Utils::UI::print_ready_interface(mode_name, model_name);
+  } else {
+    Utils::UI::print_ready_interface(mode_name, model_name);
+  }
+
+  std::vector<std::string> input_history;
   while (true) {
-    std::cout << "> ";
     std::string user_input;
-    if (!std::getline(std::cin, user_input)) {
-      break; // EOF or error
+    if (tty) {
+      std::cout << Utils::Color::DIM
+                << "\xE2\x8C\x98P palette  :cmd  !shell  /help  /debug"
+                << Utils::Color::RESET << "\n";
+      user_input = read_prompt("> ", input_history);
+      if (std::cin.eof()) {
+        break;
+      }
+    } else {
+      std::cout << "> " << std::flush;
+      if (!std::getline(std::cin, user_input)) {
+        break;
+      }
     }
 
     user_input = trim_copy(user_input);
     if (user_input.empty())
       continue;
 
+    if (tty) {
+      input_history.push_back(user_input);
+    }
+
     if (user_input == "exit" || user_input == "quit")
       break;
-    if (user_input == "help") {
-      Utils::UI::print_help();
-      continue;
-    }
-    if (user_input == "version") {
+
+    // Input bar will be cleared and redrawn by draw_input_bar on next loop
+
+    if (user_input == "help" || user_input == "?") {
+      process_user_input("/help");
+    } else if (user_input == "version") {
       Version::print_version_info();
-      continue;
-    }
-    if (user_input == "update") {
+    } else if (user_input == "update") {
       std::cout << "Checking for updates...\n";
       std::string latest = Version::check_update();
       if (latest.empty()) {
@@ -108,101 +595,63 @@ void Agent::run() {
       } else if (Version::download_and_install(latest)) {
         std::cout << "Restart cursor to use the new version.\n";
       }
-      continue;
+    } else {
+      process_user_input(user_input);
     }
-
-    process_user_input(user_input);
   }
 
+  if (tty) {
+    Utils::UI::exit_chat_mode();
+  }
   std::cout << "Goodbye\n";
 }
 
 void Agent::initialize_mode() {
-  // Data-driven provider configuration
-  struct ProviderInfo {
-    int choice;
-    Mode mode;
-    std::string env_var;
-    std::string display_name;
-  };
-
-  std::vector<ProviderInfo> providers = {
-      {1, Agent::Mode::MODE_TOGETHER, "TOGETHER_API_KEY", "Together AI"},
-      {2, Agent::Mode::MODE_CEREBRAS, "CEREBRAS_API_KEY", "Cerebras"},
-      {3, Agent::Mode::MODE_FIREWORKS, "FIREWORKS_API_KEY", "Fireworks"},
-      {4, Agent::Mode::MODE_GROQ, "GROQ_API_KEY", "Groq"},
-      {5, Agent::Mode::MODE_DEEPSEEK, "DEEPSEEK_API_KEY", "DeepSeek"},
-      {6, Agent::Mode::MODE_OPENAI, "OPENAI_API_KEY", "OpenAI"}};
-
-  // Simplified mode selection with consistent numbering
-  int choice =
-      get_user_choice("Mode [1=Online / 2=Offline] (default 2): ", {1, 2}, 2);
-
-  if (choice == 1) {
-    // Online mode: pick provider
-    std::string prompt = "Provider [";
-    for (size_t i = 0; i < providers.size(); ++i) {
-      if (i > 0)
-        prompt += " / ";
-      prompt +=
-          std::to_string(providers[i].choice) + "=" + providers[i].display_name;
-    }
-    prompt += "] (default 1): ";
-
-    std::vector<int> valid_choices;
-    for (const auto &p : providers)
-      valid_choices.push_back(p.choice);
-
-    int provider_choice = get_user_choice(prompt, valid_choices, 1);
-
-    // Find and configure the selected provider
-    for (const auto &provider : providers) {
-      if (provider.choice == provider_choice) {
-        mode_ = provider.mode;
-        api_key_ = Utils::Config::get_env_var(provider.env_var);
-        if (api_key_.empty()) {
-          throw std::runtime_error(provider.env_var + " not set");
+  std::vector<std::string> modes = {"Online", "Offline"};
+  int choice = show_menu("Mode", modes, 1);
+
+  if (choice == 0) {
+    std::vector<std::string> providers = {
+        "Together AI", "Cerebras", "Fireworks",
+        "Groq", "DeepSeek", "OpenAI"};
+    std::vector<Mode> provider_modes = {
+        Agent::Mode::MODE_TOGETHER, Agent::Mode::MODE_CEREBRAS,
+        Agent::Mode::MODE_FIREWORKS, Agent::Mode::MODE_GROQ,
+        Agent::Mode::MODE_DEEPSEEK, Agent::Mode::MODE_OPENAI};
+    std::vector<std::string> provider_keys = {
+        "TOGETHER_API_KEY", "CEREBRAS_API_KEY", "FIREWORKS_API_KEY",
+        "GROQ_API_KEY", "DEEPSEEK_API_KEY", "OPENAI_API_KEY"};
+
+    int p = show_menu("Provider", providers, 0);
+    mode_ = provider_modes[p];
+    api_key_ = Utils::Config::get_env_var(provider_keys[p]);
+    if (api_key_.empty()) {
+      throw std::runtime_error(provider_keys[p] + " not set");
+    }
+  } else {
+    std::vector<std::string> models;
+    try {
+      auto response = Services::WebService::fetch_url("http://localhost:11434/api/tags");
+      if (response.success && !response.content.empty()) {
+        auto json = nlohmann::json::parse(response.content);
+        if (json.contains("models") && json["models"].is_array()) {
+          for (const auto &m : json["models"]) {
+            if (m.contains("name")) {
+              models.push_back(m["name"]);
+            }
+          }
         }
-        Utils::UI::print_success(provider.display_name);
-        break;
       }
+    } catch (...) {
     }
-  } else {
-    // Data-driven offline model configuration
-    struct ModelInfo {
-      int choice;
-      Mode mode;
-      std::string display_name;
-    };
 
-    std::vector<ModelInfo> models = {
-        {1, Agent::Mode::MODE_LLAMA_3B, "llama3.2:3b"},
-        {2, Agent::Mode::MODE_LLAMA_LATEST, "llama3.2:latest"},
-        {3, Agent::Mode::MODE_LLAMA_31, "llama3.1:latest"}};
-
-    // Offline mode: pick model
-    std::string prompt = "Model [";
-    for (size_t i = 0; i < models.size(); ++i) {
-      if (i > 0)
-        prompt += " / ";
-      prompt += std::to_string(models[i].choice) + "=" + models[i].display_name;
+    if (models.empty()) {
+      models = {"llama3.2:3b", "llama3.2:latest", "llama3.1:latest"};
     }
-    prompt += "] (default 1): ";
-
-    std::vector<int> valid_choices;
-    for (const auto &m : models)
-      valid_choices.push_back(m.choice);
 
-    int model_choice = get_user_choice(prompt, valid_choices, 1);
-
-    // Find and configure the selected model
-    for (const auto &model : models) {
-      if (model.choice == model_choice) {
-        mode_ = model.mode;
-        Utils::UI::print_success(model.display_name);
-        break;
-      }
-    }
+    int m = show_menu("Model", models, 0);
+    mode_ = Mode::MODE_LLAMA_3B;
+    ollama_model_ = models[m];
   }
 }
 
@@ -215,64 +664,131 @@ bool Agent::is_online_mode() const {
          mode_ == Agent::Mode::MODE_OPENAI;
 }
 
-int Agent::get_user_choice(const std::string &prompt,
-                           const std::vector<int> &valid_choices,
-                           int default_choice) {
-  while (true) {
-    std::cout << prompt;
-    std::string input;
-    if (!std::getline(std::cin, input)) {
-      // EOF -> return default
-      return default_choice;
-    }
+int Agent::show_menu(const std::string &title,
+                     const std::vector<std::string> &items,
+                     int default_index) {
+  bool tty = is_tty_stream(stdin) && is_tty_stream(stdout);
+  if (!tty || items.empty()) {
+    return default_index;
+  }
 
-    input = trim_copy(input);
+#ifdef _WIN32
+  (void)title;
+  return default_index;
+#else
+  int selected = std::clamp(default_index, 0, (int)items.size() - 1);
 
-    // Accept empty line as confirmation of default choice
-    if (input.empty())
-      return default_choice;
+  std::cout << "\033[?25l";
 
-    try {
-      int choice = std::stoi(input);
-      if (std::find(valid_choices.begin(), valid_choices.end(), choice) !=
-          valid_choices.end()) {
-        return choice;
+  struct termios oldt, newt;
+  tcgetattr(STDIN_FILENO, &oldt);
+  newt = oldt;
+  newt.c_lflag &= ~(ICANON | ECHO);
+  tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+
+  std::cout << title << ":\n";
+  for (size_t i = 0; i < items.size(); i++) {
+    std::cout << (i == (size_t)selected ? "> " : "  ") << items[i] << "\n";
+  }
+
+  int ch;
+  while (true) {
+    ch = std::cin.get();
+
+    if (ch == '\n' || ch == '\r') {
+      break;
+    }
+
+    if (ch == 0x1B && std::cin.get() == '[') {
+      int arrow = std::cin.get();
+      if (arrow == 'A' && selected > 0) {
+        selected--;
+      } else if (arrow == 'B' && selected < (int)items.size() - 1) {
+        selected++;
+      } else {
+        continue;
+      }
+      // Move back to first item line and redraw
+      std::cout << "\033[" << items.size() << "A";
+      for (size_t i = 0; i < items.size(); i++) {
+        std::cout << (i == (size_t)selected ? "> " : "  ") << items[i] << "\033[K\n";
       }
-    } catch (const std::exception &) {
-      // fallthrough -> invalid input, prompt again
     }
-    Utils::UI::print_warning("Invalid choice, please try again.");
   }
+
+  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+
+  // Clear menu and print selection
+  std::cout << "\033[" << items.size() << "A\033[J";
+  std::cout << Utils::Color::GREEN << title << ": " << Utils::Color::RESET
+            << items[selected] << "\n";
+  std::cout << "\033[?25h";
+
+  return selected;
+#endif
 }
 
-void Agent::process_user_input(const std::string &input) {
+std::string Agent::process_user_input(const std::string &input) {
   command_count_++;
   std::string trimmed_input = trim_copy(input);
+  show_reasoning_header("INPUT RECEIVED");
+  show_pipeline_section("Input classification");
+  show_parsed_input(input, trimmed_input);
+
+  if (shell_mode_ && !trimmed_input.starts_with("!")) {
+    show_pipeline_section("Shell mode handling");
+    show_reasoning_step("Shell mode", "active");
+    show_reasoning_step("Command", "!" + trimmed_input);
+    handle_shell_command("!" + trimmed_input);
+    return {};
+  }
 
   // Handle @ file injection commands
   if (trimmed_input.find('@') != std::string::npos) {
+    show_pipeline_section("File injection detection");
+    show_reasoning_step("Detected", "file injection");
     handle_file_injection_command(trimmed_input);
-    return;
+    return {};
   }
 
   // Handle ! shell commands
   if (trimmed_input.starts_with("!")) {
+    show_pipeline_section("Shell command execution");
+    show_reasoning_step("Command", trimmed_input);
     handle_shell_command(trimmed_input);
-    return;
+    return {};
   }
 
   // Handle / meta commands
   if (trimmed_input.starts_with("/")) {
+    show_pipeline_section("Meta command execution");
+    show_reasoning_step("Command", trimmed_input);
     handle_meta_command(trimmed_input);
-    return;
+    return {};
   }
 
-  // Check for direct commands (detect colon)
-  if (trimmed_input.find(':') != std::string::npos) {
+  if (is_direct_command_input(trimmed_input)) {
+    show_reasoning_header("DIRECT COMMAND");
+    show_pipeline_section("Direct command execution");
+    show_parsed_input(trimmed_input, "direct command: " + trimmed_input);
+    show_context_state();
     handle_direct_command(trimmed_input);
-  } else {
-    handle_ai_chat(trimmed_input);
+    return {};
   }
+  if (auto mapped_command = map_nl_to_direct_command(trimmed_input)) {
+    show_reasoning_header("NATURAL LANGUAGE TOOLING");
+    show_pipeline_section("Natural language mapping");
+    show_reasoning_step("User intent", trimmed_input);
+    show_reasoning_step("Mapped to", *mapped_command);
+    show_context_state();
+    handle_direct_command(*mapped_command);
+    return {};
+  }
+
+  show_reasoning_header("AI CHAT");
+  show_pipeline_section("AI reasoning flow");
+  show_context_state();
+  return handle_ai_chat(trimmed_input);
 }
 
 void Agent::handle_direct_command(const std::string &input) {
@@ -311,6 +827,9 @@ void Agent::handle_direct_command(const std::string &input) {
     }
     result = Services::CommandService::execute(command);
     memory_->save_interaction("cmd:" + command, result);
+  } else if (input.starts_with("build:")) {
+    handle_direct_command("cmd:" + trim_copy(input.substr(6)));
+    return;
   } else if (input.starts_with("read:")) {
     std::string params = trim_copy(input.substr(5));
     // Check if it has range parameters: read:filename:start:count
@@ -340,6 +859,7 @@ void Agent::handle_direct_command(const std::string &input) {
         result = "Error: " + validation.error_message;
       } else {
         result = Services::FileService::read_file(params);
+        show_file_preview(params, result, 30);
       }
     }
     memory_->save_interaction("read:" + params, result);
@@ -414,10 +934,14 @@ void Agent::handle_direct_command(const std::string &input) {
       result = "No matches found for pattern: " + pattern;
     } else {
       result = "Found " + std::to_string(search_results.size()) + " matches:\n";
+      std::vector<std::string> formatted_results;
       for (const auto &match : search_results) {
-        result += match.file_path + ":" + std::to_string(match.line_number) +
-                  ": " + match.line_content + "\n";
+        std::string line_text = match.file_path + ":" + std::to_string(match.line_number) +
+                  ": " + match.line_content;
+        result += line_text + "\n";
+        formatted_results.push_back(line_text);
       }
+      show_search_results(pattern, formatted_results);
     }
     memory_->save_interaction("grep:" + pattern, result);
   } else if (input.starts_with("remember:")) {
@@ -471,6 +995,8 @@ void Agent::handle_direct_command(const std::string &input) {
       result = Services::GitService::get_git_log(path, 7);
     } else if (params.find("status") == 0) {
       result = Services::GitService::get_git_status(path);
+      auto files = Services::GitService::get_working_tree_changed_files(path);
+      show_git_status_results(files);
     } else if (params.find("analyze") == 0) {
       result = Services::GitService::analyze_repository(path);
     } else {
@@ -538,19 +1064,24 @@ void Agent::handle_direct_command(const std::string &input) {
     result = "Unknown command";
   }
 
+  show_operation_result("Operation complete", result);
   if (!result.empty()) {
     std::cout << result << std::endl;
   }
 }
 
-void Agent::handle_ai_chat(const std::string &input) {
+std::string Agent::handle_ai_chat(const std::string &input) {
   if (!ai_service_) {
     ai_service_ = std::make_unique<Services::AIService>(mode_, api_key_);
+    if (!ollama_model_.empty()) {
+      ai_service_->set_model_name(ollama_model_);
+    }
   }
 
   if (!ai_service_->is_available()) {
-    std::cout << "AI service unavailable\n";
-    return;
+    std::string msg = "AI service unavailable\n";
+    std::cout << msg;
+    return msg;
   }
 
   std::atomic<bool> done(false);
@@ -566,6 +1097,14 @@ void Agent::handle_ai_chat(const std::string &input) {
     full_context = hierarchical_context + "\n\n" + memory_context;
   }
 
+  std::string agent_context = build_agent_context();
+  if (!agent_context.empty()) {
+    full_context = agent_context + "\n\n" + full_context;
+  }
+
+  std::string system_prompt = "You are an advanced AI agent with comprehensive codebase analysis capabilities.";
+  show_ai_prompt(system_prompt, input);
+
   std::string response = ai_service_->chat(input, full_context);
 
   done = true;
@@ -573,16 +1112,24 @@ void Agent::handle_ai_chat(const std::string &input) {
     spin.join();
 
   if (!response.empty()) {
-    std::cout << response << std::endl;
+    if (is_tty_stream(stdout)) {
+      std::string formatted_response = render_markdown(response);
+      std::cout << format_message("Cursor", formatted_response) << "\n";
+    } else {
+      std::cout << response << "\n";
+    }
     memory_->save_interaction(input, response);
+
+    return response;
   } else {
     std::cout << "No response\n";
+    return "No response\n";
   }
 }
 
 void Agent::handle_file_injection_command(const std::string &input) {
-  // Process @ file injections and then send to AI
   std::string processed_input = process_file_injections(input);
+  // Result is printed by the caller via process_user_input's return
   handle_ai_chat(processed_input);
 }
 
@@ -623,9 +1170,17 @@ void Agent::handle_meta_command(const std::string &input) {
   std::string command = trim_copy(input.substr(1));
 
   if (command == "help" || command == "?") {
-    show_meta_help();
+    show_agent_documentation();
+  } else if (command == "docs") {
+    show_agent_documentation();
+  } else if (command == "debug") {
+    toggle_verbose_mode();
   } else if (command == "clear") {
     clear_screen();
+  } else if (command == "goal" || command.starts_with("goal ") ||
+             command == "task" || command.starts_with("task ") ||
+             command == "params" || command.starts_with("params ")) {
+    handle_agentic_command(command);
   } else if (command.starts_with("chat ")) {
     handle_chat_management(command.substr(5));
   } else if (command == "tools") {
@@ -804,9 +1359,20 @@ bool Agent::should_skip_file(const std::string &file_path,
 
 void Agent::show_meta_help() {
   std::cout << "Available meta commands:" << std::endl;
-  std::cout << "  /help or /?           - Show this help" << std::endl;
-  std::cout << "  /clear                - Clear screen" << std::endl;
-  std::cout << "  /chat save <tag>      - Save conversation state" << std::endl;
+  std::cout << "  /help or /?             - Show this help" << std::endl;
+  std::cout << "  /debug                  - Toggle verbose/debug mode" << std::endl;
+  std::cout << "  /clear                  - Clear screen" << std::endl;
+  std::cout << "  /goal set <description> - Set a project goal" << std::endl;
+  std::cout << "  /goal show              - Show current goal and task status" << std::endl;
+  std::cout << "  /goal clear             - Clear goal, tasks, and params" << std::endl;
+  std::cout << "  /task add <description> - Add a task for the current goal" << std::endl;
+  std::cout << "  /task list              - List active tasks" << std::endl;
+  std::cout << "  /task complete <id>     - Mark a task complete" << std::endl;
+  std::cout << "  /task remove <id>       - Remove a task" << std::endl;
+  std::cout << "  /params set key=value   - Set goal/task parameters" << std::endl;
+  std::cout << "  /params show            - Show current parameters" << std::endl;
+  std::cout << "  /params clear           - Clear current parameters" << std::endl;
+  std::cout << "  /chat save <tag>        - Save conversation state" << std::endl;
   std::cout << "  /chat resume <tag>    - Resume conversation state"
             << std::endl;
   std::cout << "  /chat list            - List saved conversations"
@@ -857,6 +1423,414 @@ void Agent::show_meta_help() {
   std::cout << "Shell commands:" << std::endl;
   std::cout << "  !<command>            - Execute shell command" << std::endl;
   std::cout << "  !                     - Toggle shell mode" << std::endl;
+  std::cout << "  /docs                 - Show agent documentation" << std::endl;
+}
+
+void Agent::handle_agentic_command(const std::string &command) {
+  if (command == "goal" || command == "goal show") {
+    show_goal();
+  } else if (command.starts_with("goal set ")) {
+    set_goal(trim_copy(command.substr(9)));
+  } else if (command == "goal clear") {
+    clear_goal();
+  } else if (command == "task" || command == "task list") {
+    list_tasks();
+  } else if (command.starts_with("task add ")) {
+    add_task(trim_copy(command.substr(9)));
+  } else if (command.starts_with("task complete ")) {
+    complete_task(trim_copy(command.substr(14)));
+  } else if (command.starts_with("task remove ")) {
+    remove_task(trim_copy(command.substr(12)));
+  } else if (command == "params" || command == "params show") {
+    show_params();
+  } else if (command.starts_with("params set ")) {
+    set_param(trim_copy(command.substr(11)));
+  } else if (command == "params clear") {
+    agent_params_.clear();
+    std::cout << "Cleared agent parameters." << std::endl;
+  } else {
+    show_agentic_help();
+  }
+}
+
+void Agent::show_agentic_help() {
+  std::cout << "Agentic workflow commands:" << std::endl;
+  std::cout << "  /goal set <description> - Set or update the project goal" << std::endl;
+  std::cout << "  /goal show              - Show active goal and tasks" << std::endl;
+  std::cout << "  /goal clear             - Clear the current goal and tasks" << std::endl;
+  std::cout << "  /task add <description> - Add a task to the current goal" << std::endl;
+  std::cout << "  /task list              - List active tasks" << std::endl;
+  std::cout << "  /task complete <id>     - Mark a task as completed" << std::endl;
+  std::cout << "  /task remove <id>       - Remove a task" << std::endl;
+  std::cout << "  /params set key=value   - Set structured goal/task parameters" << std::endl;
+  std::cout << "  /params show            - Show task parameters" << std::endl;
+  std::cout << "  /params clear           - Clear current task parameters" << std::endl;
+}
+
+void Agent::set_goal(const std::string &goal) {
+  if (goal.empty()) {
+    std::cout << "Usage: /goal set <description>" << std::endl;
+    return;
+  }
+  active_goal_ = goal;
+  tasks_.clear();
+  agent_params_.clear();
+  std::cout << "Goal set: " << active_goal_ << std::endl;
+  memory_->save_interaction("goal:set", active_goal_);
+}
+
+void Agent::show_goal() const {
+  if (active_goal_.empty()) {
+    std::cout << "No active goal set." << std::endl;
+    return;
+  }
+  std::cout << "Active goal: " << active_goal_ << std::endl;
+  if (tasks_.empty()) {
+    std::cout << "No tasks added yet." << std::endl;
+  } else {
+    std::cout << "Tasks:" << std::endl;
+    for (const auto &task : tasks_) {
+      std::cout << "  [" << (task.completed ? "x" : " ") << "] "
+                << task.id << ": " << task.description << std::endl;
+    }
+  }
+  if (!agent_params_.empty()) {
+    std::cout << "Parameters:" << std::endl;
+    for (const auto &pair : agent_params_) {
+      std::cout << "  " << pair.first << " = " << pair.second << std::endl;
+    }
+  }
+}
+
+void Agent::clear_goal() {
+  active_goal_.clear();
+  tasks_.clear();
+  agent_params_.clear();
+  std::cout << "Cleared goal, tasks, and parameters." << std::endl;
+  memory_->save_interaction("goal:clear", "Cleared goal and task state");
+}
+
+void Agent::add_task(const std::string &task_description) {
+  if (task_description.empty()) {
+    std::cout << "Usage: /task add <description>" << std::endl;
+    return;
+  }
+
+  int task_id = tasks_.empty() ? 1 : tasks_.back().id + 1;
+  tasks_.push_back({task_id, task_description, false});
+  std::cout << "Task added: [" << task_id << "] " << task_description
+            << std::endl;
+  memory_->save_interaction("task:add", task_description);
+}
+
+void Agent::list_tasks() const {
+  if (tasks_.empty()) {
+    std::cout << "No active tasks." << std::endl;
+    return;
+  }
+  std::cout << "Active tasks:" << std::endl;
+  for (const auto &task : tasks_) {
+    std::cout << "  [" << (task.completed ? "x" : " ") << "] "
+              << task.id << ": " << task.description << std::endl;
+  }
+}
+
+void Agent::complete_task(const std::string &args) {
+  if (args.empty()) {
+    std::cout << "Usage: /task complete <id>" << std::endl;
+    return;
+  }
+  try {
+    int task_id = std::stoi(args);
+    for (auto &task : tasks_) {
+      if (task.id == task_id) {
+        task.completed = true;
+        std::cout << "Task completed: [" << task_id << "] "
+                  << task.description << std::endl;
+        memory_->save_interaction("task:complete", task.description);
+        return;
+      }
+    }
+    std::cout << "Task not found: " << args << std::endl;
+  } catch (const std::exception &) {
+    std::cout << "Invalid task id: " << args << std::endl;
+  }
+}
+
+void Agent::remove_task(const std::string &args) {
+  if (args.empty()) {
+    std::cout << "Usage: /task remove <id>" << std::endl;
+    return;
+  }
+  try {
+    int task_id = std::stoi(args);
+    auto it = std::remove_if(tasks_.begin(), tasks_.end(),
+                             [&](const AgentTask &task) {
+                               return task.id == task_id;
+                             });
+    if (it != tasks_.end()) {
+      std::cout << "Task removed: " << task_id << std::endl;
+      tasks_.erase(it, tasks_.end());
+      memory_->save_interaction("task:remove", std::to_string(task_id));
+    } else {
+      std::cout << "Task not found: " << args << std::endl;
+    }
+  } catch (const std::exception &) {
+    std::cout << "Invalid task id: " << args << std::endl;
+  }
+}
+
+void Agent::set_param(const std::string &param_string) {
+  size_t equals_pos = param_string.find('=');
+  if (equals_pos == std::string::npos) {
+    std::cout << "Usage: /params set key=value" << std::endl;
+    return;
+  }
+  std::string key = trim_copy(param_string.substr(0, equals_pos));
+  std::string value = trim_copy(param_string.substr(equals_pos + 1));
+  if (key.empty() || value.empty()) {
+    std::cout << "Usage: /params set key=value" << std::endl;
+    return;
+  }
+  agent_params_[key] = value;
+  std::cout << "Parameter set: " << key << " = " << value << std::endl;
+  memory_->save_interaction("params:set", key + "=" + value);
+}
+
+void Agent::show_params() const {
+  if (agent_params_.empty()) {
+    std::cout << "No parameters set." << std::endl;
+    return;
+  }
+  std::cout << "Agent parameters:" << std::endl;
+  for (const auto &pair : agent_params_) {
+    std::cout << "  " << pair.first << " = " << pair.second << std::endl;
+  }
+}
+
+std::string Agent::build_agent_context() const {
+  if (active_goal_.empty() && tasks_.empty() && agent_params_.empty()) {
+    return "";
+  }
+
+  std::ostringstream context;
+  if (!active_goal_.empty()) {
+    context << "Current objective: " << active_goal_ << "\n";
+  }
+  if (!tasks_.empty()) {
+    context << "Tasks:\n";
+    for (const auto &task : tasks_) {
+      context << "- [" << (task.completed ? "x" : " ") << "] "
+              << task.id << ": " << task.description << "\n";
+    }
+  }
+  if (!agent_params_.empty()) {
+    context << "Parameters:\n";
+    for (const auto &pair : agent_params_) {
+      context << "- " << pair.first << " = " << pair.second << "\n";
+    }
+  }
+  context << "Use this goal, task list, and parameters to guide your next actions.";
+  return context.str();
+}
+
+void Agent::show_agent_documentation() {
+  std::string help_path = "AGENTS.md";
+  std::string doc = Services::FileService::read_file(help_path);
+  if (doc.starts_with("Error:")) {
+    std::filesystem::path current = std::filesystem::current_path();
+    while (true) {
+      std::filesystem::path candidate = current / "AGENTS.md";
+      if (Services::FileService::file_exists(candidate.string())) {
+        help_path = candidate.string();
+        doc = Services::FileService::read_file(help_path);
+        break;
+      }
+      if (!current.has_parent_path() || current == current.parent_path()) {
+        break;
+      }
+      current = current.parent_path();
+    }
+  }
+
+  if (doc.starts_with("Error:")) {
+    std::cout << "Unable to load runtime help from AGENTS.md: " << doc
+              << std::endl;
+    std::cout << "Falling back to built-in help.\n";
+    show_meta_help();
+    return;
+  }
+
+  std::cout << "Runtime help from AGENTS.md:\n" << doc << std::endl;
+}
+
+void Agent::toggle_verbose_mode() {
+  verbose_mode_ = !verbose_mode_;
+  std::cout << (verbose_mode_ ? Utils::Color::GREEN : Utils::Color::YELLOW)
+            << (verbose_mode_ ? "[debug] Verbose mode ON"
+                               : "[debug] Verbose mode OFF")
+            << Utils::Color::RESET << std::endl;
+}
+
+void Agent::show_reasoning_header(const std::string &operation_type) {
+  if (!verbose_mode_)
+    return;
+  std::cout << "\n" << Utils::Color::CYAN << "=== " << Utils::Color::BOLD
+            << operation_type << Utils::Color::RESET << Utils::Color::CYAN
+            << " ===" << Utils::Color::RESET << std::endl;
+}
+
+void Agent::show_pipeline_section(const std::string &section_title) {
+  if (!verbose_mode_)
+    return;
+  std::cout << "\n" << Utils::Color::BOLD << Utils::Color::CYAN << "[ "
+            << section_title << " ]" << Utils::Color::RESET << std::endl;
+}
+
+void Agent::show_reasoning_step(const std::string &label,
+                                const std::string &detail) {
+  if (!verbose_mode_)
+    return;
+  std::cout << Utils::Color::CYAN << "  - " << Utils::Color::RESET << label;
+  if (!detail.empty()) {
+    std::cout << ": " << Utils::Color::YELLOW << detail << Utils::Color::RESET;
+  }
+  std::cout << std::endl;
+}
+
+void Agent::show_parsed_input(const std::string &input,
+                              const std::string &parsed_as) {
+  if (!verbose_mode_)
+    return;
+  show_reasoning_step("Heard", input);
+  show_reasoning_step("Parsed as", parsed_as);
+}
+
+void Agent::show_context_state() {
+  if (!verbose_mode_)
+    return;
+  std::cout << Utils::Color::PINK << "Agent Context:" << Utils::Color::RESET
+            << std::endl;
+  if (!active_goal_.empty()) {
+    std::cout << "  Goal: " << active_goal_ << std::endl;
+  }
+  if (!tasks_.empty()) {
+    std::cout << "  Tasks: " << tasks_.size() << " active";
+    int completed = 0;
+    for (const auto &t : tasks_) {
+      if (t.completed) completed++;
+    }
+    if (completed > 0)
+      std::cout << " (" << completed << " completed)";
+    std::cout << std::endl;
+  }
+  if (!agent_params_.empty()) {
+    std::cout << "  Params: " << agent_params_.size() << " set" << std::endl;
+  }
+}
+
+void Agent::show_ai_prompt(const std::string &system_prompt,
+                           const std::string &user_input) {
+  if (!verbose_mode_)
+    return;
+  show_pipeline_section("AI prompt construction");
+  show_reasoning_step("System prompt length",
+                      std::to_string(system_prompt.length()) + " chars");
+  show_reasoning_step("User input preview",
+                      user_input.length() > 100
+                          ? user_input.substr(0, 100) + "..."
+                          : user_input);
+}
+
+void Agent::show_operation_result(const std::string &operation,
+                                  const std::string &result) {
+  if (!verbose_mode_)
+    return;
+  std::cout << Utils::Color::GREEN << "[ok] " << operation << ": "
+            << Utils::Color::RESET;
+  if (result.length() > 150) {
+    std::cout << result.substr(0, 150) << "..." << std::endl;
+  } else {
+    std::cout << result << std::endl;
+  }
+}
+
+void Agent::show_search_results(const std::string &query,
+                                const std::vector<std::string> &results) {
+  if (!verbose_mode_ || results.empty())
+    return;
+  std::cout << "\n" << Utils::Color::GREEN << "Search results for '"
+            << query << "' (" << results.size() << " matches)"
+            << Utils::Color::RESET << std::endl;
+  int line_num = 1;
+  for (const auto &result : results) {
+    std::cout << Utils::Color::CYAN << std::setw(4) << std::right << line_num
+              << Utils::Color::RESET << ": " << result << std::endl;
+    line_num++;
+  }
+}
+
+void Agent::show_git_status_results(const std::vector<std::string> &files) {
+  if (!verbose_mode_)
+    return;
+  if (files.empty()) {
+    std::cout << Utils::Color::GREEN << "[ok] Working directory clean" << Utils::Color::RESET << std::endl;
+    return;
+  }
+  std::cout << "\n" << Utils::Color::YELLOW << "Modified / Untracked files (" << files.size() << ")" << Utils::Color::RESET << std::endl;
+  int i = 1;
+  for (const auto &f : files) {
+    std::cout << Utils::Color::PINK << std::setw(3) << i << Utils::Color::RESET << " " << f << std::endl;
+    i++;
+  }
+}
+
+static std::string detect_language_from_filename(const std::string &filename) {
+  auto pos = filename.find_last_of('.');
+  if (pos == std::string::npos)
+    return "";
+  std::string ext = filename.substr(pos + 1);
+  if (ext == "cpp" || ext == "cc" || ext == "cxx" || ext == "c")
+    return "cpp";
+  if (ext == "h" || ext == "hpp" || ext == "hh")
+    return "cpp";
+  if (ext == "py")
+    return "python";
+  if (ext == "js" || ext == "ts")
+    return "javascript";
+  if (ext == "md")
+    return "markdown";
+  if (ext == "html" || ext == "htm")
+    return "html";
+  return "";
+}
+
+void Agent::show_file_preview(const std::string &filename, const std::string &content, int max_lines) {
+  if (!verbose_mode_)
+    return;
+  if (content.rfind("Error:", 0) == 0) {
+    // content starts with Error:
+    std::cout << Utils::Color::RED << content << Utils::Color::RESET << std::endl;
+    return;
+  }
+  std::string language = detect_language_from_filename(filename);
+  std::istringstream in(content);
+  std::string line;
+  int line_no = 1;
+  std::cout << "\n" << Utils::Color::GREEN << filename << Utils::Color::RESET << std::endl;
+  while (line_no <= max_lines && std::getline(in, line)) {
+    std::ostringstream pref;
+    pref << Utils::Color::CYAN << std::setw(4) << std::right << line_no << Utils::Color::RESET << ": ";
+    if (!language.empty()) {
+      std::cout << pref.str() << highlight_code_line(line, language) << std::endl;
+    } else {
+      std::cout << pref.str() << replace_inline_markdown(line) << std::endl;
+    }
+    line_no++;
+  }
+  if (in && !in.eof()) {
+    std::cout << Utils::Color::DIM << "... (file truncated)" << Utils::Color::RESET << std::endl;
+  }
 }
 
 void Agent::clear_screen() {
@@ -902,15 +1876,13 @@ void Agent::handle_chat_management(const std::string &command) {
 void Agent::show_available_tools() {
   std::cout << "Available tools:" << std::endl;
   std::cout << "  File Operations:" << std::endl;
-  std::cout << "    read:file[:start:count]     - Read file content"
-            << std::endl;
+  std::cout << "    read:file[:start:count]     - Read file content" << std::endl;
   std::cout << "    write:file content          - Write to file" << std::endl;
-  std::cout << "    replace:file:old:new        - Replace text in file"
-            << std::endl;
+  std::cout << "    replace:file:old:new        - Replace text in file" << std::endl;
   std::cout << "    grep:pattern[:dir[:ext]]    - Search in files" << std::endl;
+  std::cout << "    build:command               - Execute build or shell commands" << std::endl;
   std::cout << "  Project Analysis:" << std::endl;
-  std::cout << "    analyze:[path]              - Analyze project structure"
-            << std::endl;
+  std::cout << "    analyze:[path]              - Analyze project structure" << std::endl;
   std::cout << "    components:[path]           - Find main components"
             << std::endl;
   std::cout << "    todos:[path]                - Find task comments"