Update.

http_curl.h

@@ -68,7 +68,8 @@ char *curl_post(const char *url, const char *data) {
     curl_easy_setopt(curl, CURLOPT_URL, url);
     headers = curl_slist_append(headers, "Content-Type: application/json");
     char bearer_header[1337];
-    snprintf(bearer_header, sizeof(bearer_header), "Authorization: Bearer %s", resolve_api_key());
+    snprintf(bearer_header, sizeof(bearer_header), "Authorization: Bearer %s",
+             resolve_api_key());
     headers = curl_slist_append(headers, bearer_header);
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
@@ -102,7 +103,8 @@ char *curl_get(const char *url) {
     curl_easy_setopt(curl, CURLOPT_URL, url);
     headers = curl_slist_append(headers, "Content-Type: application/json");
     char bearer_header[1337];
-    snprintf(bearer_header, sizeof(bearer_header), "Authorization: Bearer %s", resolve_api_key());
+    snprintf(bearer_header, sizeof(bearer_header), "Authorization: Bearer %s",
+             resolve_api_key());
     headers = curl_slist_append(headers, bearer_header);
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);

main.c

@@ -1,8 +1,8 @@
-#include "r.h"
 #include "db_utils.h"
 #include "line.h"
 #include "markdown.h"
 #include "openai.h"
+#include "r.h"
 #include "tools.h"
 #include "utils.h"
 
@@ -12,8 +12,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
 #include <time.h>
+#include <unistd.h>
 
 volatile sig_atomic_t sigint_count = 0;
 time_t first_sigint_time = 0;
@@ -46,7 +46,8 @@ char * get_env_string(){
   }
 
   size_t bytes_read;
-    while ((bytes_read = fread(output + total_size, 1, buffer_size - total_size, fp)) > 0) {
+  while ((bytes_read = fread(output + total_size, 1, buffer_size - total_size,
+                             fp)) > 0) {
     total_size += bytes_read;
     if (total_size >= buffer_size) {
       buffer_size *= 2;
@@ -64,7 +65,6 @@ char * get_env_string(){
   // Null-terminate the output
   output[total_size] = '\0';
 
-
   pclose(fp);
   return output;
 }
@@ -185,13 +185,15 @@ static void repl(void) {
     }
     if (!strncmp(line, "!verbose", 8)) {
       is_verbose = !is_verbose;
-            fprintf(stderr, "%s\n", is_verbose ? "Verbose mode enabled" : "Verbose mode disabled");
+      fprintf(stderr, "%s\n",
+              is_verbose ? "Verbose mode enabled" : "Verbose mode disabled");
       continue;
     }
     if (line && *line != '\n')
       line_add_history(line);
     if (!strncmp(line, "!tools", 6)) {
-            printf("Available tools: %s\n", json_object_to_json_string(tools_descriptions()));
+      printf("Available tools: %s\n",
+             json_object_to_json_string(tools_descriptions()));
       continue;
     }
     if (!strncmp(line, "!models", 7)) {
@@ -233,11 +235,13 @@ static void init(void) {
   db_initialize();
   char *schema = db_get_schema();
   char payload[1024 * 1024] = {0};
-    snprintf(payload, sizeof(payload),
+  snprintf(
+      payload, sizeof(payload),
       "# LOCAL DATABASE"
       "Your have a local database that you can mutate using the query tool and "
       "the get and set tool."
-             "If you set a value using the tool, make sure that the key is stemmed and lowercased to prevent double entries."
+      "If you set a value using the tool, make sure that the key is stemmed "
+      "and lowercased to prevent double entries."
       "Dialect is sqlite. This is the schema in json format: %s. ",
       schema);
   free(schema);

markdown.h

@@ -1,45 +1,30 @@
-// Written by retoor@molodetz.nl
-
-// This program provides functionality to highlight the keywords in source code
-// using ANSI color formatting and convert Markdown syntax into ANSI-colored
-// text output.
-
-// Uses standard C libraries: <stdio.h>, <string.h>. Also utilizes ANSI escape
-// codes for text formatting.
-
-// MIT License:
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
+#include <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 
+// --- ANSI Escape Codes ---
 #define RESET "\033[0m"
 #define BOLD "\033[1m"
 #define ITALIC "\033[3m"
+#define STRIKETHROUGH "\033[9m"
+
 #define FG_YELLOW "\033[33m"
 #define FG_BLUE "\033[34m"
 #define FG_CYAN "\033[36m"
+#define FG_MAGENTA "\033[35m"
 
+#define BG_YELLOW_FG_BLACK "\033[43;30m"
+
+/**
+ * @brief Checks if a given word is a programming language keyword.
+ * * @param word The word to check.
+ * @return int 1 if it's a keyword, 0 otherwise.
+ */
 int is_keyword(const char *word) {
-
+  // A comprehensive list of keywords from various popular languages.
   const char *keywords[] = {
+      // C keywords
       "int", "float", "double", "char", "void", "if", "else", "while", "for",
       "return", "struct", "printf",
       // Rust keywords
@@ -75,33 +60,38 @@ int is_keyword(const char *word) {
   return 0;
 }
 
+/**
+ * @brief Applies basic syntax highlighting to a string of code.
+ * * @param code The code string to highlight.
+ */
 void highlight_code(const char *code) {
   const char *ptr = code;
   char buffer[4096];
   size_t index = 0;
 
   while (*ptr) {
-    if ((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z') ||
-        (*ptr == '_')) {
-      while ((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z') ||
-             (*ptr >= '0' && *ptr <= '9') || (*ptr == '_')) {
+    // Highlight keywords
+    if (isalpha((unsigned char)*ptr) || *ptr == '_') {
+      while (isalnum((unsigned char)*ptr) || *ptr == '_') {
         buffer[index++] = *ptr++;
       }
-      buffer[index] = 0;
+      buffer[index] = '\0';
 
       if (is_keyword(buffer)) {
-        printf(FG_BLUE "%s" RESET, buffer);
+        printf(FG_BLUE "%s" RESET FG_YELLOW, buffer);
       } else {
         printf("%s", buffer);
       }
       index = 0;
-    } else if (*ptr >= '0' && *ptr <= '9') {
-      while (*ptr >= '0' && *ptr <= '9') {
+      // Highlight numbers
+    } else if (isdigit((unsigned char)*ptr)) {
+      while (isdigit((unsigned char)*ptr)) {
         buffer[index++] = *ptr++;
       }
-      buffer[index] = 0;
-      printf(FG_CYAN "%s" RESET, buffer);
+      buffer[index] = '\0';
+      printf(FG_CYAN "%s" RESET FG_YELLOW, buffer);
       index = 0;
+      // Print other characters as-is
     } else {
       putchar(*ptr);
       ptr++;
@@ -109,93 +99,253 @@ void highlight_code(const char *code) {
   }
 }
 
+/**
+ * @brief Parses a Markdown string and prints it to the console with ANSI color
+ * codes.
+ *
+ * This version supports a wide range of Markdown features, including:
+ * - Headers (H1-H6)
+ * - Bold (**, __) and Italic (*, _) text
+ * - Strikethrough (~~) and Highlight (==)
+ * - Blockquotes (>), Nested Ordered (1.) and Unordered lists (*, -, +)
+ * - Inline code (`) and full code blocks (```) with syntax highlighting
+ * - Links ([text](url)) and Horizontal rules (---, ***)
+ * * @param markdown The raw Markdown string to parse.
+ */
 void parse_markdown_to_ansi(const char *markdown) {
   const char *ptr = markdown;
-  bool inside_code = false;
+  bool is_start_of_line = true;
 
   while (*ptr) {
-    if (*ptr == '`' && *(ptr + 1) != '`') {
-      inside_code = !inside_code;
-      if (inside_code) {
-        printf(FG_YELLOW);
-      } else {
-        printf(RESET);
-      }
-      ptr++;
-      continue;
-    } else if (!strncmp(ptr, "```", 3)) {
-      inside_code = !inside_code;
-      if (inside_code) {
-        ptr = strstr(ptr, "\n") + 1;
-      } else {
+    // --- Code Blocks (```) ---
+    if (is_start_of_line && strncmp(ptr, "```", 3) == 0) {
       ptr += 3;
-      }
-      if (*ptr == '\0') {
+      while (*ptr && *ptr != '\n')
+        ptr++;
+      if (*ptr)
+        ptr++;
+
+      const char *code_start = ptr;
+      const char *code_end = strstr(code_start, "```");
+
+      if (code_end) {
+        char block_buffer[code_end - code_start + 1];
+        strncpy(block_buffer, code_start, code_end - code_start);
+        block_buffer[code_end - code_start] = '\0';
+
+        printf(FG_YELLOW);
+        highlight_code(block_buffer);
+        printf(RESET);
+
+        ptr = code_end + 3;
+        if (*ptr == '\n')
+          ptr++;
+        is_start_of_line = true;
+        continue;
+      } else {
+        printf(FG_YELLOW);
+        highlight_code(code_start);
+        printf(RESET);
         break;
       }
     }
 
-    if (inside_code) {
-      char code_buffer[1024 * 1024] = {0};
-      ;
-      size_t index = 0;
+    // --- Block-level Elements (checked at the start of a line) ---
+    if (is_start_of_line) {
+      const char *line_start_ptr = ptr;
+      int indent_level = 0;
+      while (*ptr == ' ') {
+        indent_level++;
+        ptr++;
+      }
 
-      while (*ptr && *ptr != '`') {
-        code_buffer[index++] = *ptr++;
-        if (*ptr == '\n' || *ptr == ' ' || *ptr == '\t' || *ptr == '.') {
-          code_buffer[index++] = 0;
-          highlight_code(code_buffer);
-          index = 0;
-        }
-      }
-      code_buffer[index] = 0;
-      if (index) {
-        highlight_code(code_buffer);
-      }
-    } else {
-      if (strncmp(ptr, "**", 2) == 0) {
-        printf(BOLD);
-        ptr += 2;
-        while (*ptr && strncmp(ptr, "**", 2) != 0) {
-          putchar(*ptr++);
-        }
-        if (*ptr == '*' && *(ptr + 1) == '*')
-          ptr += 2;
-        printf(RESET);
-      } else if (*ptr == '*' && (ptr == markdown || *(ptr - 1) != '*')) {
-        printf(ITALIC);
-        ptr++;
-        while (*ptr && *ptr != '*') {
-          putchar(*ptr++);
-        }
-        if (*ptr == '*')
-          ptr++;
-        printf(RESET);
+      bool block_processed = true;
+      if (strncmp(ptr, "###### ", 7) == 0) {
+        printf(BOLD FG_YELLOW);
+        ptr += 7;
+      } else if (strncmp(ptr, "##### ", 6) == 0) {
+        printf(BOLD FG_YELLOW);
+        ptr += 6;
+      } else if (strncmp(ptr, "#### ", 5) == 0) {
+        printf(BOLD FG_YELLOW);
+        ptr += 5;
       } else if (strncmp(ptr, "### ", 4) == 0) {
         printf(BOLD FG_YELLOW);
         ptr += 4;
-        while (*ptr && *ptr != '\n') {
-          putchar(*ptr++);
-        }
-        printf(RESET "\n");
       } else if (strncmp(ptr, "## ", 3) == 0) {
         printf(BOLD FG_YELLOW);
         ptr += 3;
-        while (*ptr && *ptr != '\n') {
-          putchar(*ptr++);
-        }
-        printf(RESET "\n");
       } else if (strncmp(ptr, "# ", 2) == 0) {
         printf(BOLD FG_YELLOW);
         ptr += 2;
-        while (*ptr && *ptr != '\n') {
-          putchar(*ptr++);
-        }
-        printf(RESET "\n");
+      } else if ((strncmp(ptr, "---", 3) == 0 || strncmp(ptr, "***", 3) == 0) &&
+                 (*(ptr + 3) == '\n' || *(ptr + 3) == '\0')) {
+        printf(FG_CYAN "───────────────────────────────────────────────────────"
+                       "──────────" RESET "\n");
+        ptr += 3;
+        if (*ptr == '\n')
+          ptr++;
+        is_start_of_line = true;
+        continue;
+      } else if (strncmp(ptr, "> ", 2) == 0) {
+        for (int i = 0; i < indent_level; i++)
+          putchar(' ');
+        printf(ITALIC FG_CYAN "▎ " RESET);
+        ptr += 2;
+        is_start_of_line = false;
+        continue;
+      } else if ((*ptr == '*' || *ptr == '-' || *ptr == '+') &&
+                 *(ptr + 1) == ' ') {
+        for (int i = 0; i < indent_level; i++)
+          putchar(' ');
+        printf(FG_MAGENTA "• " RESET);
+        ptr += 2;
+        is_start_of_line = false;
+        continue;
       } else {
+        const char *temp_ptr = ptr;
+        while (isdigit((unsigned char)*temp_ptr))
+          temp_ptr++;
+        if (temp_ptr > ptr && *temp_ptr == '.' && *(temp_ptr + 1) == ' ') {
+          for (int i = 0; i < indent_level; i++)
+            putchar(' ');
+          printf(FG_MAGENTA);
+          fwrite(ptr, 1, (temp_ptr - ptr) + 1, stdout);
+          printf(" " RESET);
+          ptr = temp_ptr + 2;
+          is_start_of_line = false;
+          continue;
+        } else {
+          block_processed = false;
+          ptr = line_start_ptr;
+        }
+      }
+      if (block_processed) {
+        while (*ptr && *ptr != '\n')
+          putchar(*ptr++);
+        printf(RESET "\n");
+        if (*ptr == '\n')
+          ptr++;
+        is_start_of_line = true;
+        continue;
+      }
+    }
+
+    // --- Inline Elements (order is important) ---
+    if (strncmp(ptr, "***", 3) == 0 || strncmp(ptr, "___", 3) == 0) {
+      const char *marker = strncmp(ptr, "***", 3) == 0 ? "***" : "___";
+      printf(BOLD ITALIC);
+      ptr += 3;
+      const char *end = strstr(ptr, marker);
+      if (end) {
+        fwrite(ptr, 1, end - ptr, stdout);
+        ptr = end + 3;
+      } else {
+        fputs(ptr, stdout);
+        ptr += strlen(ptr);
+      }
+      printf(RESET);
+      continue;
+    }
+    if (strncmp(ptr, "**", 2) == 0 || strncmp(ptr, "__", 2) == 0) {
+      const char *marker = strncmp(ptr, "**", 2) == 0 ? "**" : "__";
+      printf(BOLD);
+      ptr += 2;
+      const char *end = strstr(ptr, marker);
+      if (end) {
+        fwrite(ptr, 1, end - ptr, stdout);
+        ptr = end + 2;
+      } else {
+        fputs(ptr, stdout);
+        ptr += strlen(ptr);
+      }
+      printf(RESET);
+      continue;
+    }
+    if ((*ptr == '*' || *ptr == '_') && !isspace(*(ptr - 1)) &&
+        !isspace(*(ptr + 1))) {
+      char marker = *ptr;
+      printf(ITALIC);
+      ptr++;
+      const char *start = ptr;
+      while (*ptr && *ptr != marker)
+        ptr++;
+      if (*ptr == marker) {
+        fwrite(start, 1, ptr - start, stdout);
+        ptr++;
+      } else {
+        putchar(marker);
+        ptr = start;
+      }
+      printf(RESET);
+      continue;
+    }
+    if (strncmp(ptr, "~~", 2) == 0) {
+      printf(STRIKETHROUGH);
+      ptr += 2;
+      const char *end = strstr(ptr, "~~");
+      if (end) {
+        fwrite(ptr, 1, end - ptr, stdout);
+        ptr = end + 2;
+      } else {
+        fputs(ptr, stdout);
+        ptr += strlen(ptr);
+      }
+      printf(RESET);
+      continue;
+    }
+    if (strncmp(ptr, "==", 2) == 0) {
+      printf(BG_YELLOW_FG_BLACK);
+      ptr += 2;
+      const char *end = strstr(ptr, "==");
+      if (end) {
+        fwrite(ptr, 1, end - ptr, stdout);
+        ptr = end + 2;
+      } else {
+        fputs(ptr, stdout);
+        ptr += strlen(ptr);
+      }
+      printf(RESET);
+      continue;
+    }
+    if (*ptr == '`' && *(ptr + 1) != '`') {
+      printf(FG_YELLOW);
+      ptr++;
+      const char *start = ptr;
+      while (*ptr && *ptr != '`')
+        ptr++;
+      fwrite(start, 1, ptr - start, stdout);
+      if (*ptr == '`')
+        ptr++;
+      printf(RESET);
+      continue;
+    }
+    if (*ptr == '[') {
+      const char *text_start = ptr + 1;
+      const char *text_end = strchr(text_start, ']');
+      if (text_end && *(text_end + 1) == '(') {
+        const char *url_start = text_end + 2;
+        const char *url_end = strchr(url_start, ')');
+        if (url_end) {
+          printf(FG_BLUE);
+          fwrite(text_start, 1, text_end - text_start, stdout);
+          printf(RESET " (");
+          printf(ITALIC FG_CYAN);
+          fwrite(url_start, 1, url_end - url_start, stdout);
+          printf(RESET ")");
+          ptr = url_end + 1;
+          continue;
+        }
+      }
+    }
+
+    // --- Default Character ---
+    if (*ptr == '\n') {
+      is_start_of_line = true;
+    } else if (!isspace((unsigned char)*ptr)) {
+      is_start_of_line = false;
+    }
     putchar(*ptr);
     ptr++;
   }
 }
-  }
-}

r.h

@@ -32,7 +32,6 @@ char *_model = NULL;
 #define DB_FILE "~/.r.db"
 #define PROMPT_TEMPERATURE 0.1
 
-
 bool use_tools() {
   if (getenv("R_USE_TOOLS") != NULL) {
     const char *value = getenv("R_USE_TOOLS");

tools.h

@@ -56,7 +56,6 @@ struct json_object *tool_description_rag_chunk();
 char *tool_function_rag_search(char *query, int top_k);
 char *tool_function_rag_chunk(char *file_path);
 
-
 char *tool_function_python_execute(char *source_code);
 
 struct json_object *tools_descriptions() {
@@ -475,8 +474,12 @@ struct json_object *tool_description_python_execute() {
   json_object_object_add(root, "type", json_object_new_string("function"));
 
   struct json_object *function = json_object_new_object();
-    json_object_object_add(function, "name", json_object_new_string("python_execute"));
-    json_object_object_add(function, "description", json_object_new_string("Executes Python source code using the python3 interpreter and returns stdout/stderr."));
+  json_object_object_add(function, "name",
+                         json_object_new_string("python_execute"));
+  json_object_object_add(
+      function, "description",
+      json_object_new_string("Executes Python source code using the python3 "
+                             "interpreter and returns stdout/stderr."));
 
   struct json_object *parameters = json_object_new_object();
   json_object_object_add(parameters, "type", json_object_new_string("object"));
@@ -484,7 +487,9 @@ struct json_object *tool_description_python_execute() {
   struct json_object *properties = json_object_new_object();
   struct json_object *source = json_object_new_object();
   json_object_object_add(source, "type", json_object_new_string("string"));
-    json_object_object_add(source, "description", json_object_new_string("Python source code to execute."));
+  json_object_object_add(
+      source, "description",
+      json_object_new_string("Python source code to execute."));
   json_object_object_add(properties, "source", source);
 
   json_object_object_add(parameters, "properties", properties);
@@ -493,7 +498,8 @@ struct json_object *tool_description_python_execute() {
   json_object_array_add(required, json_object_new_string("source"));
   json_object_object_add(parameters, "required", required);
 
-    json_object_object_add(parameters, "additionalProperties", json_object_new_boolean(0));
+  json_object_object_add(parameters, "additionalProperties",
+                         json_object_new_boolean(0));
   json_object_object_add(function, "parameters", parameters);
 
   json_object_object_add(root, "function", function);
@@ -646,7 +652,8 @@ struct json_object *tool_description_linux_terminal_interactive() {
   struct json_object *properties = json_object_new_object();
   struct json_object *path = json_object_new_object();
   json_object_object_add(path, "type", json_object_new_string("string"));
-  json_object_object_add(path, "description",
+  json_object_object_add(
+      path, "description",
       json_object_new_string(
           "Executable with parameters to execute interactively."));
   json_object_object_add(properties, "command", path);
@@ -1233,7 +1240,6 @@ char *tool_function_mkdir(char *path) {
   return strdup("Directory successfully created.");
 }
 
-
 struct json_object *tool_description_mkdir() {
   struct json_object *root = json_object_new_object();
   json_object_object_add(root, "type", json_object_new_string("function"));
@@ -1562,13 +1568,16 @@ struct json_object *tools_execute(struct json_object *tools_array) {
         }
       } else if (!strcmp(function_name, "python_execute")) {
         struct json_object *arguments_obj;
-        if (json_object_object_get_ex(function_obj, "arguments", &arguments_obj)) {
-            struct json_object *arguments = json_tokener_parse(json_object_get_string(arguments_obj));
+        if (json_object_object_get_ex(function_obj, "arguments",
+                                      &arguments_obj)) {
+          struct json_object *arguments =
+              json_tokener_parse(json_object_get_string(arguments_obj));
           struct json_object *source_obj;
           if (json_object_object_get_ex(arguments, "source", &source_obj)) {
             char *source = (char *)json_object_get_string(source_obj);
             char *result = tool_function_python_execute(source);
-                json_object_object_add(tool_result, "content", json_object_new_string(result));
+            json_object_object_add(tool_result, "content",
+                                   json_object_new_string(result));
             free(result);
           }
         }