feat(cli): cache version checks and add TTY-aware table output

Version checking:
- Results cached for 24h at ~/.config/raystack/<repo>/state.json
- Eliminates HTTP call to GitHub on every command invocation
- Cache respects XDG_CONFIG_HOME and APPDATA on Windows

Table output:
- TTY: tab-aligned columns with padding (human-friendly)
- Non-TTY: raw tab-separated values (pipe to awk/cut/jq)

Author: ravisuhag

cli/printer/printer.go

@@ -112,13 +112,21 @@ func (o *Output) YAML(data interface{}) error {
 	return nil
 }
 
-// Table writes rows as a tab-aligned table.
+// Table writes rows as a tab-aligned table when the output is a TTY.
+// When piped (non-TTY), it writes tab-separated values for easy
+// processing with tools like awk, cut, or jq.
 func (o *Output) Table(rows [][]string) {
-	tw := tabwriter.NewWriter(o.w, 0, 0, 2, ' ', 0)
-	for _, row := range rows {
-		fmt.Fprintln(tw, strings.Join(row, "\t"))
+	if o.tty {
+		tw := tabwriter.NewWriter(o.w, 0, 0, 2, ' ', 0)
+		for _, row := range rows {
+			fmt.Fprintln(tw, strings.Join(row, "\t"))
+		}
+		tw.Flush()
+	} else {
+		for _, row := range rows {
+			fmt.Fprintln(o.w, strings.Join(row, "\t"))
+		}
 	}
-	tw.Flush()
 }
 
 // --- Markdown ---

cli/version/release.go

@@ -5,6 +5,9 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
 	"time"
 
 	"github.com/hashicorp/go-version"
@@ -13,13 +16,19 @@ import (
 var (
 	timeout   = time.Second * 1
 	apiFormat = "https://api.github.com/repos/%s/releases/latest"
+	cacheTTL  = 24 * time.Hour
 )
 
 type releaseInfo struct {
 	version string
 	tarURL  string
 }
 
+type cacheEntry struct {
+	CheckedAt     time.Time `json:"checked_at"`
+	LatestVersion string    `json:"latest_version"`
+}
+
 func fetchInfo(url string) (*releaseInfo, error) {
 	httpClient := http.Client{Timeout: timeout}
 	req, err := http.NewRequest(http.MethodGet, url, nil)
@@ -77,17 +86,83 @@ func compareVersions(current, latest string) (bool, error) {
 // CheckForUpdate checks GitHub for a newer release and returns an update
 // message if one is available. Returns an empty string if up-to-date or
 // if the check fails.
+//
+// Results are cached for 24 hours to avoid hitting GitHub on every invocation.
+// The cache is stored at ~/.config/raystack/<repo>/state.json.
 func CheckForUpdate(currentVersion, repo string) string {
+	// Check cache first.
+	if latest, ok := readCache(repo); ok {
+		return buildMessage(currentVersion, latest)
+	}
+
+	// Fetch from GitHub.
 	releaseURL := fmt.Sprintf(apiFormat, repo)
 	info, err := fetchInfo(releaseURL)
 	if err != nil {
 		return ""
 	}
 
-	isLatest, err := compareVersions(currentVersion, info.version)
+	// Cache the result.
+	writeCache(repo, info.version)
+
+	return buildMessage(currentVersion, info.version)
+}
+
+func buildMessage(current, latest string) string {
+	isLatest, err := compareVersions(current, latest)
 	if err != nil || isLatest {
 		return ""
 	}
+	return fmt.Sprintf("A new release (%s) is available. consider updating to latest version.", latest)
+}
+
+func cachePath(repo string) string {
+	dir := configDir()
+	return filepath.Join(dir, "raystack", repo, "state.json")
+}
+
+func readCache(repo string) (string, bool) {
+	data, err := os.ReadFile(cachePath(repo))
+	if err != nil {
+		return "", false
+	}
+
+	var entry cacheEntry
+	if err := json.Unmarshal(data, &entry); err != nil {
+		return "", false
+	}
+
+	if time.Since(entry.CheckedAt) > cacheTTL {
+		return "", false
+	}
+
+	return entry.LatestVersion, true
+}
+
+func writeCache(repo, latestVersion string) {
+	path := cachePath(repo)
+	os.MkdirAll(filepath.Dir(path), 0755)
+
+	entry := cacheEntry{
+		CheckedAt:     time.Now(),
+		LatestVersion: latestVersion,
+	}
+	data, err := json.Marshal(entry)
+	if err != nil {
+		return
+	}
+	os.WriteFile(path, data, 0644)
+}
 
-	return fmt.Sprintf("A new release (%s) is available. consider updating to latest version.", info.version)
+func configDir() string {
+	if dir := os.Getenv("XDG_CONFIG_HOME"); dir != "" {
+		return dir
+	}
+	if runtime.GOOS == "windows" {
+		if dir := os.Getenv("APPDATA"); dir != "" {
+			return dir
+		}
+	}
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".config")
 }