fix: handle async 202 job polling and nested graph response

The /v1/graphs/supermodel endpoint returns HTTP 202 with an async job
envelope (status, jobId, retryAfter, result). The client was treating
this as a completed response and unmarshalling directly into Graph,
resulting in 0 nodes/relationships.

Changes:
- Add JobResponse and jobResult types for the async envelope
- Poll with the same idempotency key until status is "completed"
- Extract graph from the nested result.graph path
- Extract postZip helper to avoid duplicating multipart construction

Tested live against api.supermodeltools.com — correctly returns
362 files, 1527 functions, 7741 relationships for supermodel-public-api.

Author: jonathanpopham

internal/api/client.go

@@ -33,9 +33,52 @@ func New(cfg *config.Config) *Client {
 	}
 }
 
+// analyzeEndpoint is the API path for the supermodel graph analysis.
+const analyzeEndpoint = "/v1/graphs/supermodel"
+
 // Analyze uploads a repository ZIP and runs the full analysis pipeline,
-// returning the DisplayGraphResponse.
+// polling until the async job completes and returning the Graph.
 func (c *Client) Analyze(ctx context.Context, zipPath, idempotencyKey string) (*Graph, error) {
+	job, err := c.postZip(ctx, zipPath, idempotencyKey)
+	if err != nil {
+		return nil, err
+	}
+
+	// Poll until the job completes.
+	for job.Status == "pending" || job.Status == "processing" {
+		wait := time.Duration(job.RetryAfter) * time.Second
+		if wait <= 0 {
+			wait = 5 * time.Second
+		}
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		case <-time.After(wait):
+		}
+
+		job, err = c.postZip(ctx, zipPath, idempotencyKey)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if job.Error != nil {
+		return nil, fmt.Errorf("analysis failed: %s", *job.Error)
+	}
+	if job.Status != "completed" {
+		return nil, fmt.Errorf("unexpected job status: %s", job.Status)
+	}
+
+	var result jobResult
+	if err := json.Unmarshal(job.Result, &result); err != nil {
+		return nil, fmt.Errorf("decode graph result: %w", err)
+	}
+	return &result.Graph, nil
+}
+
+// postZip sends the repository ZIP to the analyze endpoint and returns the
+// raw job response (which may be pending, processing, or completed).
+func (c *Client) postZip(ctx context.Context, zipPath, idempotencyKey string) (*JobResponse, error) {
 	f, err := os.Open(zipPath)
 	if err != nil {
 		return nil, err
@@ -53,11 +96,11 @@ func (c *Client) Analyze(ctx context.Context, zipPath, idempotencyKey string) (*
 	}
 	mw.Close()
 
-	var g Graph
-	if err := c.request(ctx, http.MethodPost, "/v1/supermodel", mw.FormDataContentType(), &buf, idempotencyKey, &g); err != nil {
+	var job JobResponse
+	if err := c.request(ctx, http.MethodPost, analyzeEndpoint, mw.FormDataContentType(), &buf, idempotencyKey, &job); err != nil {
 		return nil, err
 	}
-	return &g, nil
+	return &job, nil
 }
 
 // DisplayGraph fetches the composed display graph for an already-analyzed repo.

internal/api/types.go

@@ -1,6 +1,9 @@
 package api
 
-import "fmt"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 // Node represents a graph node returned by the Supermodel API.
 type Node struct {
@@ -90,6 +93,20 @@ func (g *Graph) NodeByID(id string) (Node, bool) {
 	return Node{}, false
 }
 
+// JobResponse is the async envelope returned by the API for long-running jobs.
+type JobResponse struct {
+	Status     string          `json:"status"`
+	JobID      string          `json:"jobId"`
+	RetryAfter int             `json:"retryAfter"`
+	Error      *string         `json:"error"`
+	Result     json.RawMessage `json:"result"`
+}
+
+// jobResult is the inner result object containing the graph.
+type jobResult struct {
+	Graph Graph `json:"graph"`
+}
+
 // Error represents a non-2xx response from the API.
 type Error struct {
 	StatusCode int    `json:"-"`