Program.cs

using System.Net.Http;
using System.Text.Json;
using System.Text.Json.Serialization;

/// <summary>
/// QuickSheet Rust Crate Lookup Extension — crate info and search via crates.io API.
/// Prefix: "crates". Usage:
///   "crates: tokio"          → detail view for a specific crate
///   "crates: search async"   → top 5 crates matching search query
/// No API key required. Responses cached 30 min (crate detail) / 10 min (search).
/// </summary>
class Program
{
    private static readonly HttpClient Http = new()
    {
        Timeout = TimeSpan.FromSeconds(12),
        DefaultRequestHeaders = { { "User-Agent", "quicksheet-crates/1.0 (github.com/Deskworks/quicksheet-crates)" } }
    };

    // Caches: key → (result, fetchedAt)
    private static readonly Dictionary<string, (string result, DateTime fetchedAt)> CrateCache = new(StringComparer.OrdinalIgnoreCase);
    private static readonly Dictionary<string, (string result, DateTime fetchedAt)> SearchCache = new(StringComparer.OrdinalIgnoreCase);
    private static readonly TimeSpan CrateCacheTtl  = TimeSpan.FromMinutes(30);
    private static readonly TimeSpan SearchCacheTtl = TimeSpan.FromMinutes(10);

    static void Main()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;

        string? line;
        while ((line = Console.ReadLine()) != null)
        {
            if (string.IsNullOrWhiteSpace(line)) continue;

            try
            {
                using var doc = JsonDocument.Parse(line);
                string? type = doc.RootElement.TryGetProperty("type", out var tp) ? tp.GetString() : null;

                switch (type)
                {
                    case "init":
                        HandleInit();
                        break;
                    case "activate":
                        HandleActivate(doc.RootElement);
                        break;
                    case "deactivate":
                        HandleDeactivate();
                        break;
                }
            }
            catch (Exception ex)
            {
                SendResult($"[crates] error: {ex.Message}");
            }
        }
    }

    static void HandleInit()
    {
        var response = new
        {
            type = "init_response",
            prefix = "crates",
            name = "Rust Crate Lookup",
            description = "Look up Rust crates on crates.io. Usage: crates: <name> or crates: search <query>"
        };
        Console.WriteLine(JsonSerializer.Serialize(response));
    }

    static void HandleDeactivate()
    {
        var response = new { type = "deactivate_response" };
        Console.WriteLine(JsonSerializer.Serialize(response));
    }

    static void HandleActivate(JsonElement root)
    {
        string? cellValue = root.TryGetProperty("value", out var v) ? v.GetString() : null;
        string? id        = root.TryGetProperty("id",    out var i) ? i.GetString() : null;

        if (string.IsNullOrWhiteSpace(cellValue))
        {
            SendResult("Usage: crates: <name>  or  crates: search <query>", id);
            return;
        }

        string query = cellValue.Trim();
        string result;

        if (query.StartsWith("search ", StringComparison.OrdinalIgnoreCase))
        {
            string searchTerm = query["search ".Length..].Trim();
            result = FetchSearch(searchTerm);
        }
        else
        {
            result = FetchCrate(query);
        }

        SendResult(result, id);
    }

    static string FetchCrate(string name)
    {
        if (CrateCache.TryGetValue(name, out var cached) && DateTime.UtcNow - cached.fetchedAt < CrateCacheTtl)
            return cached.result;

        try
        {
            string url = $"https://crates.io/api/v1/crates/{Uri.EscapeDataString(name)}";
            string json = Http.GetStringAsync(url).GetAwaiter().GetResult();
            using var doc = JsonDocument.Parse(json);

            if (!doc.RootElement.TryGetProperty("crate", out var crate))
                return $"[crates] '{name}' not found on crates.io";

            string crateName    = crate.TryGetProperty("name",             out var n)  ? n.GetString()  ?? name : name;
            string version      = crate.TryGetProperty("max_version",      out var mv) ? mv.GetString() ?? "?"  : "?";
            long   downloads    = crate.TryGetProperty("downloads",        out var dl) ? dl.GetInt64()  : 0;
            long   recentDl     = crate.TryGetProperty("recent_downloads", out var rd) ? rd.GetInt64()  : 0;
            string desc         = crate.TryGetProperty("description",      out var ds) ? ds.GetString() ?? "" : "";
            string? homepage    = crate.TryGetProperty("homepage",         out var hp) ? hp.GetString() : null;
            string? repository  = crate.TryGetProperty("repository",       out var rp) ? rp.GetString() : null;

            string dlStr       = FormatCount(downloads);
            string recentStr   = FormatCount(recentDl);
            string link        = homepage ?? repository ?? $"https://crates.io/crates/{crateName}";

            string lines = $"{crateName} v{version} | ↓{dlStr} total (↓{recentStr}/mo)\n{desc.Trim()}\n{link}";

            // keywords
            if (crate.TryGetProperty("keywords", out var kw) && kw.ValueKind == JsonValueKind.Array)
            {
                var tags = new List<string>();
                foreach (var k in kw.EnumerateArray())
                    if (k.GetString() is string s) tags.Add(s);
                if (tags.Count > 0)
                    lines += $"\nkeywords: {string.Join(", ", tags)}";
            }

            CrateCache[name] = (lines, DateTime.UtcNow);
            return lines;
        }
        catch (HttpRequestException)
        {
            return $"[crates] network error fetching '{name}'";
        }
        catch (Exception ex)
        {
            return $"[crates] error: {ex.Message}";
        }
    }

    static string FetchSearch(string query)
    {
        if (SearchCache.TryGetValue(query, out var cached) && DateTime.UtcNow - cached.fetchedAt < SearchCacheTtl)
            return cached.result;

        try
        {
            string url = $"https://crates.io/api/v1/crates?q={Uri.EscapeDataString(query)}&per_page=5";
            string json = Http.GetStringAsync(url).GetAwaiter().GetResult();
            using var doc = JsonDocument.Parse(json);

            if (!doc.RootElement.TryGetProperty("crates", out var crates) || crates.ValueKind != JsonValueKind.Array)
                return $"[crates] no results for '{query}'";

            var lines = new List<string>();
            int idx = 1;
            foreach (var c in crates.EnumerateArray())
            {
                string nm   = c.TryGetProperty("name",        out var n)  ? n.GetString()  ?? "?" : "?";
                string ver  = c.TryGetProperty("max_version", out var mv) ? mv.GetString() ?? "?" : "?";
                long   dl   = c.TryGetProperty("downloads",   out var d)  ? d.GetInt64()   : 0;
                string desc = c.TryGetProperty("description", out var ds) ? ds.GetString() ?? "" : "";
                string shortDesc = desc.Length > 60 ? desc[..57] + "..." : desc;
                lines.Add($"{idx}. {nm} v{ver} ↓{FormatCount(dl)} | {shortDesc}");
                idx++;
            }

            string result = lines.Count == 0
                ? $"[crates] no results for '{query}'"
                : string.Join("\n", lines);

            SearchCache[query] = (result, DateTime.UtcNow);
            return result;
        }
        catch (HttpRequestException)
        {
            return $"[crates] network error searching '{query}'";
        }
        catch (Exception ex)
        {
            return $"[crates] error: {ex.Message}";
        }
    }

    static string FormatCount(long n)
    {
        if (n >= 1_000_000_000) return $"{n / 1_000_000_000.0:F1}B";
        if (n >= 1_000_000)     return $"{n / 1_000_000.0:F1}M";
        if (n >= 1_000)         return $"{n / 1_000.0:F0}k";
        return n.ToString();
    }

    static void SendResult(string text, string? id = null)
    {
        var response = new { type = "result", id, value = text };
        Console.WriteLine(JsonSerializer.Serialize(response));
    }
}