Merge pull request #7 from dropdevrahul/redesign-shadcn-ui

Redesign UI with shadcn/ui (Tailwind + Radix) and add Go tests

Author: dropdevrahul

AGENTS.md

@@ -0,0 +1,49 @@
+# AGENTS.md — Hypr Repository Quick Reference
+
+## What is this?
+Hypr is a **desktop REST API client** (like Postman/Insomnia) built with **Wails v2.5.1** (Go backend + React/TypeScript frontend). It runs on macOS, Windows, and Linux.
+
+## Key commands
+
+| Command | What it does |
+|---------|-------------|
+| `wails dev` | Live dev mode — Vite HMR frontend + Go backend. Opens browser on `localhost:34115`. |
+| `wails build` | Production build — outputs a native executable (name: `hypr`, per `wails.json`). |
+| `go mod tidy` | Sync Go dependencies. Wails calls `npm install` automatically. |
+| `wails doctor` | Check Wails toolchain prerequisites (native deps, etc.). |
+
+**There are no tests in this repo.** There is no `go test` or `npm test` to run.
+
+## Project structure
+
+```
+hypr/
+  main.go          — Entry point. Embeds `frontend/dist`, creates Wails window (1280×1080).
+  app.go           — Go HTTP client logic: `MakeRequest()`, `RunCurl()`, `RequestResult` struct.
+  parse_curl.go    — Curl-to-request parser. Uses `go-shellwords` to tokenize curl strings.
+  export.go        — Exports request/response to JSON via native save dialog.
+  frontend/
+    src/
+      App.tsx      — Main React component. All UI: method selector, URL, headers, body, response.
+      main.tsx     — React 18 entry point, renders `<App />`.
+    vite.config.ts — Minimal Vite config (React plugin only).
+    tsconfig.json  — TypeScript strict mode, `noEmit: true`, JSX react-jsx.
+  wails.json       — Wails config: frontend install/build hooks, output filename.
+  go.mod           — Go module: `module changeme` (⚠️ not renamed from default).
+```
+
+## Architecture notes
+
+- **Go module name is `changeme`** (`go.mod:1`). This is the default placeholder — it has not been renamed. If you import this module elsewhere, update it.
+- **Go version: 1.18** (`go.mod:2`). No newer Go features (generics, etc.) are used.
+- **Wails binds `App` struct** (`main.go:31`) to the frontend. All Go methods called from React (`MakeRequest`, `RunCurl`, `Export`) are on this struct.
+- **Frontend auto-build**: Wails runs `npm run build` (which does `tsc && vite build`) before producing the final binary. The `frontend/dist` directory is embedded into the Go binary via `//go:embed all:frontend/dist`.
+- **No CI/CD workflows** exist in this repo (no `.github/workflows/`).
+- **No linting, formatting, or typecheck scripts** — just `tsc` via the build step.
+
+## Common gotchas
+
+- **First-time setup**: Run `wails doctor` before `wails dev`. Wails needs platform-specific native toolchains (e.g., WebKit on Linux, Safari frameworks on macOS).
+- **Module name mismatch**: `go.mod` says `module changeme`. The `go:embed` path in `main.go` references `frontend/dist` — this works because Wails manages the build. But the Go module name should be updated if this project is published or imported.
+- **No hot-reload for Go code**: `wails dev` only hot-reloads the frontend (Vite HMR). Go changes require a restart.
+- **Curl parser limitations** (`parse_curl.go`): Handles basic curl flags (`-X`, `-H`, `-d`, `-A`, `-u`, `-I`, `-b`). Does not handle `--data-binary`, `--data-urlencode`, or complex multi-part uploads.

CLAUDE.md

@@ -0,0 +1,44 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+Hypr is a desktop REST API client (like Postman/Insomnia) built with **Wails v2** (Go backend + React/TypeScript frontend). The Go HTTP client does the actual network calls; the React app is the UI.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `wails dev` | Live dev mode — Vite HMR for the frontend + Go backend. Also serves a browser dev server at `http://localhost:34115` where Go methods are callable from devtools. |
+| `wails build` | Production build — embeds `frontend/dist` and outputs a native executable named `hypr` (per `wails.json`). |
+| `go mod tidy` | Sync Go dependencies. |
+| `wails doctor` | Check the Wails toolchain / native prerequisites. Run this before `wails dev` on a fresh machine. |
+| `npm run build` (in `frontend/`) | `tsc && vite build`. Wails runs this automatically during `wails build`; run it manually to typecheck. |
+
+Go has unit tests — run them with `go test ./...` (curl parser and HTTP helpers; see `parse_curl_test.go`, `app_test.go`). The frontend has **no test runner**; its only check is `tsc` via the build. There is **no lint/format/CI** config.
+
+**Go changes are not hot-reloaded** — `wails dev` only HMRs the frontend. Restart `wails dev` after editing Go.
+
+## Architecture
+
+The frontend↔backend boundary is the only non-obvious part. Wails binds the Go `App` struct (`main.go`, `Bind: []interface{}{app}`) and code-generates TypeScript wrappers into `frontend/wailsjs/`. The React app imports those wrappers (`../wailsjs/go/main/App`) and calls Go methods as promises.
+
+**Three bound Go methods** (all on `App`, all callable from React):
+- `MakeRequest(url, method, body, headers)` — builds and sends the HTTP request via the shared `http.Client` (50s timeout, created in `startup`), returns a `RequestResult`. JSON response bodies are pretty-indented server-side.
+- `RunCurl(curl)` — parses a curl string into a `Request`, then calls `MakeRequest`.
+- `Export(req, reqHeaders, reqBodies, result)` — opens a native save dialog and writes the request/response as JSON.
+
+`RequestResult` (`app.go`) is the single response shape returned to the UI: `Body`, `HeadersStr` (newline-joined response headers), `Error`, plus echoed-back request fields. Errors are returned **inside** `RequestResult.Error`, not as a thrown/rejected promise — the UI checks `result.Error`.
+
+**Curl parsing** (`parse_curl.go`): a hand-written state machine over `go-shellwords` tokens. Supports `-X/--request`, `-H/--header`, `-d/--data[-ascii|-raw]`, `-A/--user-agent`, `-u/--user` (→ Basic auth), `-I/--head`, `-b/--cookie`. Does **not** handle `--data-binary`, `--data-urlencode`, or multipart. Input must start with `curl `.
+
+**Frontend state** (`frontend/src/App.tsx`): the UI is multi-tab ("Request 1", "Request 2", …). State is held as **parallel arrays indexed by tab** — `reqBodies[]`, `reqHeaders[][]`, `responses[]` — all kept in sync in `addNewTab`/`closeTab`. When editing tab logic, update all three arrays together or they desync. Headers in the UI are `{Key, Value}` objects (`src/lib/header.ts`); they're converted to a plain `Record<string, string>` before being passed to Go (which expects `main.Headers`).
+
+**UI stack**: the frontend uses **Tailwind CSS + shadcn/ui** (Radix primitives in `frontend/src/components/ui/`, `cn` helper in `src/lib/utils.ts`, design tokens as CSS variables in `src/index.css`, theme in `tailwind.config.js`). Icons are `lucide-react`. JSON responses are highlighted by the in-house `src/components/json-view.tsx` (no `react-json-pretty`). The `@/*` import alias maps to `src/`.
+
+## Gotchas
+
+- **Go module is named `changeme`** (`go.mod` placeholder, never renamed). Build works because Wails manages it; rename before publishing/importing.
+- **`frontend/hypr/` is a stale leftover** — a complete nested Wails scaffold (its own `go.mod`, `main.go`, `build/`, `frontend/`). It is **not** part of the real app (the real entry point is the root `main.go`). Don't edit files there expecting them to take effect.
+- **`frontend/wailsjs/` is generated** — `App.d.ts`/`App.js`/`models.ts` are regenerated by Wails from the Go structs. Don't hand-edit; change the Go types and rebuild.

app_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"net/http"
+	"testing"
+)
+
+func TestHeadersToStr_SingleValue(t *testing.T) {
+	h := http.Header{"Content-Type": []string{"application/json"}}
+	if got := HeadersToStr(&h); got != "Content-Type: application/json" {
+		t.Errorf("HeadersToStr() = %q, want %q", got, "Content-Type: application/json")
+	}
+}
+
+func TestHeadersToStr_MultipleValuesJoined(t *testing.T) {
+	h := http.Header{"Set-Cookie": []string{"a=1", "b=2"}}
+	if got := HeadersToStr(&h); got != "Set-Cookie: a=1; b=2" {
+		t.Errorf("HeadersToStr() = %q, want %q", got, "Set-Cookie: a=1; b=2")
+	}
+}
+
+func TestHeadersToStr_Empty(t *testing.T) {
+	h := http.Header{}
+	if got := HeadersToStr(&h); got != "" {
+		t.Errorf("HeadersToStr() = %q, want empty", got)
+	}
+}

frontend/index.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8"/>
     <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
-    <title>Hpyr</title>
+    <title>Hypr</title>
 </head>
 <body>
 <div id="root"></div>