greeenboii 0.1.7 → 0.1.8

data/lib/greeenboii.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "greeenboii/version"
+require_relative "libsql"
 require "cli/ui"
 require "date"
 require "console_table"
@@ -10,6 +11,13 @@ require "httparty"
 
 require "sqlite3"
 
+require 'json'
+require 'net/http'
+require 'uri'
+
+require 'dotenv'
+require 'fileutils'
+
 module Greeenboii
   class Error < StandardError; end
 
@@ -412,6 +420,430 @@ module Greeenboii
     end
   end
 
+  class GistManager
+    def initialize
+      Dotenv.load
+      ensure_connection
+    end
+
+    private def ensure_connection
+      return true
+
+      CLI::UI.puts(CLI::UI.fmt("{{yellow:⚠}} Turso credentials not found"))
+      manage_credentials
+    end
+
+    def add_gist
+      unless true
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗}} Cloud credentials required"))
+        return
+      end
+
+      title = CLI::UI.ask("Enter a title for this gist:")
+      return if title.empty?
+
+      url = CLI::UI.ask("Enter GitHub Gist URL:")
+      return if url.empty? || !url.match?(/https:\/\/gist\.github\.com\//)
+
+      description = CLI::UI.ask("Enter a description (optional):", default: "")
+      tags = CLI::UI.ask("Enter tags (comma separated):", default: "")
+
+      # Extract gist ID from URL
+      gist_id = url.split('/').last
+      created_at = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+
+      CLI::UI::Spinner.spin("Saving gist...") do |spinner|
+        begin
+          # First create table if needed
+          create_table_result = turso_execute(
+            "CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)"
+          )
+
+          # Then insert the data
+          insert_result = turso_execute(
+            "INSERT OR REPLACE INTO gists (gist_id, title, url, description, tags, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+            [gist_id, title, url, description, tags, created_at]
+          )
+
+          spinner.update_title("Gist saved successfully")
+        rescue => e
+          spinner.update_title("Error saving gist: #{e.message}")
+        end
+      end
+    end
+
+    def list_gists
+      unless true
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗}} Cloud credentials required"))
+        return
+      end
+
+      CLI::UI::Spinner.spin("Fetching gists...") do |spinner|
+        begin
+          # Create table if needed
+          create_table_result = turso_execute(
+            "CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)"
+          )
+
+          # Get all gists
+          result = turso_execute(
+            "SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC"
+          )
+
+          @gists = extract_rows(result)
+
+          if @gists.empty?
+            spinner.update_title("No gists found")
+          else
+            spinner.update_title("Found #{@gists.length} gists")
+          end
+        rescue => e
+          spinner.update_title("Error fetching gists: #{e.message}")
+        end
+      end
+
+      return if !@gists || @gists.empty?
+
+      CLI::UI.puts("\nYour Gists:")
+      @gists.each do |gist|
+        gist_id, title, url, description, tags, created_at = gist
+        CLI::UI.puts(CLI::UI.fmt("{{cyan:#{gist_id}}}: {{bold:#{title}}} - #{url}"))
+        CLI::UI.puts(CLI::UI.fmt("   Description: #{description}")) if description && !description.empty?
+        CLI::UI.puts(CLI::UI.fmt("   Tags: #{tags}")) if tags && !tags.empty?
+        CLI::UI.puts(CLI::UI.fmt("   Created: #{created_at}"))
+        CLI::UI.puts("")
+      end
+    end
+
+    def search_gists
+      unless true
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗}} Cloud credentials required"))
+        return
+      end
+
+      term = CLI::UI.ask("Enter search term:")
+      return if term.empty?
+
+      CLI::UI::Spinner.spin("Searching gists...") do |spinner|
+        begin
+          result = turso_execute(
+            "SELECT gist_id, title, url, description, tags, created_at FROM gists WHERE title LIKE ? OR description LIKE ? OR tags LIKE ? ORDER BY created_at DESC",
+            ["%#{term}%", "%#{term}%", "%#{term}%"]
+          )
+
+          @search_results = extract_rows(result)
+
+          if @search_results.empty?
+            spinner.update_title("No matching gists found")
+          else
+            spinner.update_title("Found #{@search_results.length} matching gists")
+          end
+        rescue => e
+          spinner.update_title("Search error: #{e.message}")
+        end
+      end
+
+      return if !@search_results || @search_results.empty?
+
+      CLI::UI.puts(CLI::UI.fmt("\n{{bold:Search Results:}}"))
+      @search_results.each do |gist|
+        gist_id, title, url, description, tags, created_at = gist
+        CLI::UI.puts(CLI::UI.fmt("{{cyan:#{gist_id}}}: {{bold:#{title}}} - #{url}"))
+        CLI::UI.puts(CLI::UI.fmt("   Description: #{description}")) if description && !description.empty?
+        CLI::UI.puts(CLI::UI.fmt("   Tags: #{tags}")) if tags && !tags.empty?
+        CLI::UI.puts(CLI::UI.fmt("   Created: #{created_at}"))
+        CLI::UI.puts("")
+      end
+    end
+
+    def open_gist
+      list_gists
+
+      return if !@gists || @gists.empty?
+
+      gist_id = CLI::UI.ask("Enter gist ID to open:")
+      return if gist_id.empty?
+
+      # Find the matching gist
+      gist = @gists.find { |g| g[0] == gist_id }
+
+      unless gist
+        CLI::UI.puts(CLI::UI.fmt("{{red:✗}} Gist not found"))
+        return
+      end
+
+      url = gist[2] # URL is at index 2
+
+      if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/)
+        system("start #{url}")
+      elsif RUBY_PLATFORM.match?(/darwin/)
+        system("open #{url}")
+      elsif RUBY_PLATFORM.match?(/linux/)
+        system("xdg-open #{url}")
+      else
+        CLI::UI.puts(CLI::UI.fmt("{{yellow:⚠}} Couldn't determine how to open URL on your platform. URL: #{url}"))
+      end
+    end
+
+    def delete_gist
+      list_gists
+
+      return if !@gists || @gists.empty?
+
+      gist_id = CLI::UI.ask("Enter gist ID to delete:")
+      return if gist_id.empty?
+
+      CLI::UI::Spinner.spin("Deleting gist...") do |spinner|
+        begin
+          result = turso_execute("DELETE FROM gists WHERE gist_id = ?", [gist_id])
+
+          # Try to determine if rows were affected
+          affected_rows = get_affected_rows(result)
+
+          if affected_rows > 0
+            spinner.update_title("Gist deleted successfully")
+          else
+            spinner.update_title("Gist not found")
+          end
+        rescue => e
+          spinner.update_title("Error deleting gist: #{e.message}")
+        end
+      end
+    end
+
+    def manage_credentials
+      CLI::UI::Frame.divider("{{v}} Cloud Credentials")
+
+      current_url = 'https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline'
+      current_token = "[Hidden]"
+
+      CLI::UI.puts(CLI::UI.fmt("Current settings:"))
+      CLI::UI.puts(CLI::UI.fmt("Database URL: {{cyan:#{current_url}}}"))
+      CLI::UI.puts(CLI::UI.fmt("Auth Token: {{cyan:#{current_token}}}"))
+      CLI::UI.puts("")
+
+      CLI::UI::Prompt.ask("Credential Options:") do |handler|
+        handler.option("Update Database URL") do
+          url = CLI::UI.ask("Enter Turso Database URL:")
+          update_env_file('TURSO_DATABASE_URL', url) unless url.empty?
+        end
+
+        handler.option("Update Auth Token") do
+          token = CLI::UI.ask("Enter Turso Auth Token:")
+          update_env_file('TURSO_AUTH_TOKEN', token) unless token.empty?
+        end
+
+        handler.option("Test Connection") do
+          test_connection
+        end
+
+        handler.option("Back") { return }
+      end
+    end
+
+    private def update_env_file(key, value)
+      env_file = '.env'
+
+      # Read existing .env content
+      content = File.exist?(env_file) ? File.read(env_file) : ""
+      lines = content.split("\n")
+
+      # Find and replace the line with the key, or add it
+      key_found = false
+      lines.map! do |line|
+        if line.start_with?("#{key}=")
+          key_found = true
+          "#{key}=#{value}"
+        else
+          line
+        end
+      end
+
+      lines << "#{key}=#{value}" unless key_found
+
+      # Write back to file
+      File.write(env_file, lines.join("\n"))
+
+      # Reload environment
+      ENV[key] = value
+
+      CLI::UI.puts(CLI::UI.fmt("{{v}} Updated #{key} in .env file"))
+    end
+
+    private def test_connection
+      CLI::UI::Spinner.spin("Testing Turso connection...") do |spinner|
+        begin
+          unless true
+            spinner.update_title("Cloud credentials not found")
+            next
+          end
+
+          result = turso_execute("SELECT 1")
+          spinner.update_title("Connection successful!")
+        rescue => e
+          spinner.update_title("Connection failed: #{e.message}")
+        end
+      end
+    end
+
+    def show_menu
+      CLI::UI::Frame.divider("{{v}} Gist Manager")
+      loop do
+        CLI::UI::Prompt.ask("Gist Manager Options:") do |handler|
+          handler.option("Add Gist")          { add_gist }
+          handler.option("List Gists")        { list_gists }
+          handler.option("Search Gists")      { search_gists }
+          handler.option("Open Gist")         { open_gist }
+          handler.option("Delete Gist")       { delete_gist }
+          handler.option("Cloud Settings")    { manage_credentials }
+          handler.option("Exit")              { return }
+        end
+      end
+    end
+
+    private def turso_execute(sql, params = [])
+      url = 'https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline'
+      auth_token = 'eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE3NDY0NzY5MjUsImlkIjoiMmMyYjBmYmItMzg0OC00ZDM2LThmYzQtZTNkMmFhMTU4Nzk4IiwicmlkIjoiNDc5ZmE0YjMtY2YwNS00ZmI2LWFlOGUtOWY0YWQ1Yjk5MzRjIn0.qdU6U9kLYGqUXVs62XswYsKGxS4tpO7WkbGePvtCI5IlOhQlxqUVL9nMP87ppd7T6IQ3Irksdn5PGMS8zI_yAQ'
+
+      # Ensure URL has the correct endpoint path for v2 pipeline
+      url = url.end_with?('/v2/pipeline') ? url : "#{url}/v2/pipeline"
+
+      uri = URI(url)
+      request = Net::HTTP::Post.new(uri)
+      request["Authorization"] = "Bearer #{auth_token}"
+      request["Content-Type"] = "application/json"
+
+      # Format parameters into the required format
+      formatted_params = params.map do |param|
+        type = case param
+               when Integer, /^\d+$/
+                 "integer"
+               when Float, /^\d+\.\d+$/
+                 "float"
+               when TrueClass, FalseClass, /^(true|false)$/i
+                 "boolean"
+               when NilClass
+                 "null"
+               else
+                 "text"
+               end
+
+        {
+          "type": type,
+          "value": param.to_s
+        }
+      end
+
+      # Build the request body
+      stmt = {
+        "sql": sql,
+        "args": formatted_params
+      }
+
+      payload = {
+        "requests": [
+          { "type": "execute", "stmt": stmt },
+          { "type": "close" }
+        ]
+      }
+
+      request.body = JSON.generate(payload)
+
+      begin
+        # Log the request for debugging
+        ensure_log_directory
+        File.open('logs/turso_requests.log', 'a') do |f|
+          f.puts "#{Time.now} - REQUEST to #{uri}"
+          f.puts "SQL: #{sql}"
+          f.puts "Params: #{params.inspect}"
+          f.puts "Formatted Params: #{formatted_params.inspect}"
+          f.puts "Payload: #{payload.to_json}"
+          f.puts "-" * 80
+        end
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+
+        # Log the response
+        ensure_log_directory
+        File.open('logs/turso_responses.log', 'a') do |f|
+          f.puts "#{Time.now} - RESPONSE (#{response.code})"
+          f.puts "Body: #{response.body}"
+          f.puts "-" * 80
+        end
+
+        if response.code != "200"
+          error_msg = "HTTP error: #{response.code} - #{response.body}"
+          log_error(error_msg)
+          raise error_msg
+        end
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        error_msg = "JSON parse error: #{e.message}. Response body: #{response&.body}"
+        log_error(error_msg)
+        raise error_msg
+      rescue => e
+        error_msg = "Query failed: #{e.message}"
+        log_error(error_msg)
+        raise error_msg
+      end
+    end
+
+    private def log_error(message)
+      ensure_log_directory
+      File.open('logs/turso_errors.log', 'a') do |f|
+        f.puts "#{Time.now} - ERROR"
+        f.puts message
+        f.puts "-" * 80
+      end
+      # Also output to console
+      CLI::UI.puts(CLI::UI.fmt("{{red:ERROR}}: #{message}"))
+    end
+
+    private def ensure_log_directory
+      FileUtils.mkdir_p('logs') unless Dir.exist?('logs')
+    end
+
+    private def extract_rows(result)
+      rows = []
+
+      if result &&
+         result["results"] &&
+         result["results"][0] &&
+         result["results"][0]["type"] == "ok" &&
+         result["results"][0]["response"] &&
+         result["results"][0]["response"]["type"] == "execute" &&
+         result["results"][0]["response"]["result"]
+
+        result_data = result["results"][0]["response"]["result"]
+
+        if result_data["rows"]
+          rows = result_data["rows"]
+        end
+      end
+
+      rows
+    end
+
+    private def get_affected_rows(result)
+      if result &&
+         result["results"] &&
+         result["results"][0] &&
+         result["results"][0]["type"] == "ok" &&
+         result["results"][0]["response"] &&
+         result["results"][0]["response"]["type"] == "execute" &&
+         result["results"][0]["response"]["result"] &&
+         result["results"][0]["response"]["result"]["affected_row_count"]
+
+        return result["results"][0]["response"]["result"]["affected_row_count"]
+      end
+
+      0
+    end
+  end
+
   class Options
     def self.show_options
       CLI::UI::Prompt.instructions_color = CLI::UI::Color::GRAY
@@ -422,6 +854,7 @@ module Greeenboii
         handler.option("{{green:Website Builder}}") { |_selection| WebsiteBuilder.build_website }
         handler.option("{{yellow:Todo List}}") { |_selection| TodoList.new.show_menu }
         handler.option("{{cyan:Search Engine}}") { |_selection| Search.perform_search }
+        handler.option("{{blue:Gist Manager}}") { |_selection| GistManager.new.show_menu }
         handler.option("{{red:Exit}}") { |_selection| exit }
       end
     end

data/lib/libsql.rb

@@ -0,0 +1,159 @@
+# lib/libsql.rb
+require 'net/http'
+require 'json'
+require 'uri'
+require 'dotenv'
+
+module Libsql
+  class Database
+    def initialize(url:, auth_token:)
+      # Ensure URL has the correct endpoint path
+      @url = url.end_with?('/v2/pipeline') ? url : "#{url}/v2/pipeline"
+      @auth_token = auth_token
+    end
+
+    def connect
+      connection = Connection.new(@url, @auth_token)
+      yield connection if block_given?
+      connection
+    end
+  end
+
+  class Connection
+    def initialize(url, auth_token)
+      @url = url
+      @auth_token = auth_token
+      @last_changes = 0
+    end
+
+    def execute(query, *params)
+      params = params.flatten if params.is_a?(Array)
+      execute_stmt(query, params)
+    end
+
+    def execute_batch(batch_query)
+      # Split the batch query into individual statements
+      statements = batch_query.split(';').map(&:strip).reject(&:empty?)
+
+      requests = statements.map do |stmt|
+        { "type" => "execute", "stmt" => { "sql" => stmt } }
+      end
+
+      # Add close request at the end
+      requests << { "type" => "close" }
+
+      execute_pipeline(requests)
+    end
+
+    def query(query, *params)
+      params = params.flatten if params.is_a?(Array)
+      result = execute_stmt(query, params)
+      QueryResult.new(result)
+    end
+
+    def changes
+      @last_changes
+    end
+
+    private
+
+    def execute_stmt(sql, params)
+      requests = [
+        { "type" => "execute", "stmt" => { "sql" => sql, "args" => params } },
+        { "type" => "close" }
+      ]
+
+      execute_pipeline(requests)
+    end
+
+    def execute_pipeline(requests)
+      uri = URI(@url)
+      request = Net::HTTP::Post.new(uri)
+      request["Authorization"] = "Bearer #{@auth_token}"
+      request["Content-Type"] = "application/json"
+
+      request.body = JSON.generate({
+        "requests" => requests
+      })
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request(request)
+      end
+
+      if response.code != "200"
+        raise "Query failed: #{response.body}"
+      end
+
+      response_data = JSON.parse(response.body)
+
+      # Extract the affected row count for UPDATE/DELETE operations
+      if response_data["results"] &&
+         response_data["results"][0] &&
+         response_data["results"][0]["type"] == "ok" &&
+         response_data["results"][0]["response"] &&
+         response_data["results"][0]["response"]["type"] == "execute" &&
+         response_data["results"][0]["response"]["result"] &&
+         response_data["results"][0]["response"]["result"]["affected_row_count"]
+        @last_changes = response_data["results"][0]["response"]["result"]["affected_row_count"]
+      end
+
+      response_data
+    end
+  end
+
+  class QueryResult
+    def initialize(result)
+      @result = result
+
+      # Extract columns and rows from Turso's format
+      if @result["results"] &&
+         @result["results"][0] &&
+         @result["results"][0]["type"] == "ok" &&
+         @result["results"][0]["response"] &&
+         @result["results"][0]["response"]["type"] == "execute" &&
+         @result["results"][0]["response"]["result"]
+
+        result_data = @result["results"][0]["response"]["result"]
+        @columns = result_data["cols"] || []
+        @rows = result_data["rows"] || []
+      else
+        @columns = []
+        @rows = []
+      end
+    end
+
+    def empty?
+      @rows.empty?
+    end
+
+    def to_a
+      @rows
+    end
+
+    def close
+      # No-op for HTTP API
+    end
+  end
+
+  # Helper method to create a database connection using .env credentials
+  def self.connect_with_env
+    Dotenv.load
+
+    # Check for required environment variables
+    unless ENV['TURSO_DATABASE_URL'] && ENV['TURSO_AUTH_TOKEN']
+      raise "Missing TURSO_DATABASE_URL or TURSO_AUTH_TOKEN in .env file"
+    end
+
+    db = Database.new(
+      url: ENV['TURSO_DATABASE_URL'],
+      auth_token: ENV['TURSO_AUTH_TOKEN']
+    )
+
+    # If a block is given, yield connection
+    if block_given?
+      db.connect { |conn| yield conn }
+    else
+      db
+    end
+  end
+end

data/logs/turso_requests.log

@@ -0,0 +1,54 @@
+2025-05-06 12:20:41 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:20:42 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: INSERT OR REPLACE INTO gists (gist_id, title, url, description, tags, created_at) VALUES (?, ?, ?, ?, ?, ?)
+Params: ["2fc9fa3eac1f0ddeb2f0b23aa21bbe4b", "compilerdesign", "https://gist.github.com/greeenboi/2fc9fa3eac1f0ddeb2f0b23aa21bbe4b", "nil", "nil", "2025-05-06 12:20:41"]
+Formatted Params: [{:type=>"text", :value=>"2fc9fa3eac1f0ddeb2f0b23aa21bbe4b"}, {:type=>"text", :value=>"compilerdesign"}, {:type=>"text", :value=>"https://gist.github.com/greeenboi/2fc9fa3eac1f0ddeb2f0b23aa21bbe4b"}, {:type=>"text", :value=>"nil"}, {:type=>"text", :value=>"nil"}, {:type=>"text", :value=>"2025-05-06 12:20:41"}]
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"INSERT OR REPLACE INTO gists (gist_id, title, url, description, tags, created_at) VALUES (?, ?, ?, ?, ?, ?)","args":[{"type":"text","value":"2fc9fa3eac1f0ddeb2f0b23aa21bbe4b"},{"type":"text","value":"compilerdesign"},{"type":"text","value":"https://gist.github.com/greeenboi/2fc9fa3eac1f0ddeb2f0b23aa21bbe4b"},{"type":"text","value":"nil"},{"type":"text","value":"nil"},{"type":"text","value":"2025-05-06 12:20:41"}]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:20:46 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:20:46 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:35:11 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: SELECT 1
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"SELECT 1","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:35:14 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:35:14 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:38:06 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"CREATE TABLE IF NOT EXISTS gists (gist_id TEXT PRIMARY KEY, title TEXT NOT NULL, url TEXT NOT NULL, description TEXT, tags TEXT, created_at TEXT)","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------
+2025-05-06 12:38:06 +0530 - REQUEST to https://greeenboii-cli-db-greeenboi.aws-ap-south-1.turso.io/v2/pipeline
+SQL: SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC
+Params: []
+Formatted Params: []
+Payload: {"requests":[{"type":"execute","stmt":{"sql":"SELECT gist_id, title, url, description, tags, created_at FROM gists ORDER BY created_at DESC","args":[]}},{"type":"close"}]}
+--------------------------------------------------------------------------------