Program.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace QuickSheetHackage;

class Program
{
    static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(10) };
    static readonly Dictionary<string, (string data, DateTime fetched)> Cache = new();
    static readonly TimeSpan CacheTtl = TimeSpan.FromMinutes(30);

    static int _anchorRow, _anchorCol;

    static async Task Main()
    {
        Http.DefaultRequestHeaders.Add("User-Agent", "quicksheet-hackage/1.0");

        string? line;
        while ((line = Console.ReadLine()) != null)
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
            try
            {
                using var doc = JsonDocument.Parse(line);
                var root = doc.RootElement;
                var msgType = root.GetProperty("type").GetString() ?? "";

                if (msgType == "activate")
                {
                    var anchor = root.GetProperty("anchor");
                    _anchorRow = anchor.GetProperty("row").GetInt32();
                    _anchorCol = anchor.GetProperty("col").GetInt32();

                    string value = "";
                    if (root.TryGetProperty("value", out var v))
                        value = v.GetString() ?? "";
                    else if (root.TryGetProperty("params", out var p))
                    {
                        var arr = p.EnumerateArray();
                        if (arr.MoveNext()) value = arr.Current.GetString() ?? "";
                    }

                    await HandleCommand(value.Trim());
                }
            }
            catch (Exception ex)
            {
                WriteError($"Error: {ex.Message}");
            }
        }
    }

    static async Task HandleCommand(string value)
    {
        var query = value;
        if (query.StartsWith("hackage:", StringComparison.OrdinalIgnoreCase))
            query = query[8..].Trim();

        if (string.IsNullOrWhiteSpace(query))
        {
            Write(0, 0, "hackage: <package>  or  hackage: search <term>");
            return;
        }

        if (query.StartsWith("search ", StringComparison.OrdinalIgnoreCase))
            await DoSearch(query[7..].Trim());
        else
            await DoLookup(query);
    }

    static async Task DoLookup(string packageName)
    {
        Write(0, 0, $"Fetching {packageName}...");

        try
        {
            var versionsJson = await Fetch($"https://hackage.haskell.org/package/{packageName}.json");
            using var versDoc = JsonDocument.Parse(versionsJson);

            var latestVersion = "";
            var versionCount = 0;
            foreach (var prop in versDoc.RootElement.EnumerateObject())
            {
                versionCount++;
                if (prop.Value.GetString() == "normal")
                    latestVersion = BetterVersion(latestVersion, prop.Name);
            }

            if (string.IsNullOrEmpty(latestVersion))
            {
                WriteError($"Package '{packageName}' not found.");
                return;
            }

            var cabalUrl = $"https://hackage.haskell.org/package/{packageName}-{latestVersion}/{packageName}.cabal";
            var cabal = await Fetch(cabalUrl);

            var synopsis = ExtractCabal(cabal, "synopsis") ?? "(no synopsis)";
            var author = ExtractCabal(cabal, "author") ?? "";
            var category = ExtractCabal(cabal, "category") ?? "";
            var homepage = ExtractCabal(cabal, "homepage") ?? $"https://hackage.haskell.org/package/{packageName}";
            var license = ExtractCabal(cabal, "license") ?? "";

            var row = 0;
            Write(row++, 0, $"[Hackage] {packageName}");
            Write(row++, 0, $"  Version:   {latestVersion}  ({versionCount} total)");
            Write(row++, 0, $"  Synopsis:  {Truncate(synopsis, 56)}");
            if (!string.IsNullOrEmpty(author))
                Write(row++, 0, $"  Author:    {Truncate(author, 56)}");
            if (!string.IsNullOrEmpty(category))
                Write(row++, 0, $"  Category:  {category}");
            if (!string.IsNullOrEmpty(license))
                Write(row++, 0, $"  License:   {license}");
            Write(row++, 0, $"  Hackage:   hackage.haskell.org/package/{packageName}");
            if (homepage != $"https://hackage.haskell.org/package/{packageName}")
                Write(row++, 0, $"  Homepage:  {Truncate(homepage, 56)}");
        }
        catch (HttpRequestException)
        {
            WriteError($"Package '{packageName}' not found on Hackage.");
        }
        catch (Exception ex)
        {
            WriteError($"Error: {ex.Message}");
        }
    }

    static async Task DoSearch(string term)
    {
        Write(0, 0, $"Searching Hackage for '{term}'...");

        try
        {
            var url = $"https://hackage.haskell.org/packages/search?terms={Uri.EscapeDataString(term)}";
            var html = await Http.GetStringAsync(url);

            var results = ParseSearchResults(html);
            if (results.Count == 0)
            {
                WriteError($"No results for '{term}'.");
                return;
            }

            var row = 0;
            Write(row++, 0, $"[Hackage] search: {term}  ({results.Count} results)");
            Write(row++, 0, $"  {"Package",-28} {"Tags/Category",-20}");
            Write(row++, 0, new string('─', 60));

            var shown = 0;
            foreach (var r in results)
            {
                if (shown >= 8) break;
                Write(row++, 0, $"  {r.Name,-28} {Truncate(r.Category, 20)}");
                if (!string.IsNullOrEmpty(r.Synopsis))
                    Write(row++, 0, $"    {Truncate(r.Synopsis, 58)}");
                shown++;
            }

            if (results.Count > 8)
                Write(row, 0, $"  +{results.Count - 8} more — refine with: hackage: search {term}");
        }
        catch (Exception ex)
        {
            WriteError($"Search error: {ex.Message}");
        }
    }

    static List<SearchResult> ParseSearchResults(string html)
    {
        var results = new List<SearchResult>();

        // Try JSON format first
        try
        {
            using var doc = JsonDocument.Parse(html);
            if (doc.RootElement.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in doc.RootElement.EnumerateArray())
                {
                    var name = item.TryGetProperty("name", out var n) ? n.GetString() ?? "" : "";
                    var synopsis = item.TryGetProperty("synopsis", out var s) ? s.GetString() ?? "" : "";
                    var category = item.TryGetProperty("category", out var c) ? c.GetString() ?? "" : "";
                    if (!string.IsNullOrEmpty(name))
                        results.Add(new SearchResult(name, synopsis, category));
                }
                return results;
            }
        }
        catch { /* HTML, parse below */ }

        // HTML: extract package names from the browse table
        // Rows look like: <a href="/package/NAME">NAME</a>
        var nameRx = new Regex(@"href=""/package/([^/""]+)""[^>]*>[^<]*</a>", RegexOptions.Compiled);
        var synRx = new Regex(@"<td[^>]*class=""snippet""[^>]*>([^<]*)</td>", RegexOptions.Compiled);
        var tagRx = new Regex(@"<td[^>]*class=""tags""[^>]*>(.*?)</td>", RegexOptions.Compiled | RegexOptions.Singleline);

        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        foreach (Match m in nameRx.Matches(html))
        {
            var pkg = m.Groups[1].Value;
            // Skip well-known non-package URLs
            if (pkg.Contains('-') || char.IsLetter(pkg[0]))
                if (seen.Add(pkg))
                    results.Add(new SearchResult(pkg, "", ""));
        }

        return results;
    }

    static string BetterVersion(string a, string b)
    {
        if (string.IsNullOrEmpty(a)) return b;
        if (string.IsNullOrEmpty(b)) return a;
        var av = ParseVersion(a);
        var bv = ParseVersion(b);
        for (int i = 0; i < Math.Max(av.Length, bv.Length); i++)
        {
            int ai = i < av.Length ? av[i] : 0;
            int bi = i < bv.Length ? bv[i] : 0;
            if (ai != bi) return ai > bi ? a : b;
        }
        return a;
    }

    static int[] ParseVersion(string v)
    {
        var parts = v.Split('.');
        var r = new int[parts.Length];
        for (int i = 0; i < parts.Length; i++)
            int.TryParse(parts[i], out r[i]);
        return r;
    }

    static string? ExtractCabal(string cabal, string field)
    {
        var m = Regex.Match(cabal, $@"^{field}:\s*(.+)$", RegexOptions.Multiline | RegexOptions.IgnoreCase);
        return m.Success ? m.Groups[1].Value.Trim() : null;
    }

    static string Truncate(string s, int max)
        => s.Length <= max ? s : s[..(max - 1)] + "\u2026";

    static void Write(int rowOffset, int colOffset, string text)
    {
        var msg = new { type = "write", cells = new[] { new { r = _anchorRow + rowOffset, c = _anchorCol + colOffset, v = text } } };
        Console.WriteLine(JsonSerializer.Serialize(msg));
    }

    static async Task<string> Fetch(string url)
    {
        if (Cache.TryGetValue(url, out var cached) && DateTime.UtcNow - cached.fetched < CacheTtl)
            return cached.data;
        var data = await Http.GetStringAsync(url);
        Cache[url] = (data, DateTime.UtcNow);
        return data;
    }

    static void WriteError(string message)
        => Write(0, 0, $"Error: {message}");

    record SearchResult(string Name, string Synopsis, string Category);
}