fix(graphstore): raise memory provider MaxLimit 100 -> 10000 (#56)

The in-memory GraphStore advertised MaxLimit 100 while the default local.ladybug
provider advertises 1000, so a `limit 1000` query that is valid in production was
rejected with "query limit exceeds provider capability" whenever the memory
provider backs the server (--quickstart, MCP, the demos).

Memory has no storage backend, so give it a generous 10000 row ceiling — kept
>= the default provider's 1000 so any production-valid limit is also valid here.
Row prealloc is already bounded at 1024, so large limits just grow the slice.

Adds a regression test. Verified end-to-end: `.entity ... | limit 1000` returns
Success on a memory-backed server; limit > 10000 is still rejected.

Author: qiansheng91

internal/graphstore/memory.go

@@ -256,8 +256,11 @@ func (s *MemoryStore) Capabilities(ctx context.Context) (model.GraphStoreCapabil
 		TimeVisibility:     true,
 		ServerSideFilter:   false,
 		MaxDepth:           2,
-		MaxLimit:           100,
-		Timeout:            "10s",
+		// Memory backs --quickstart / MCP / demos and has no storage backend, so
+		// it serves a generous row ceiling. Kept >= the default local.ladybug
+		// provider's 1000 so any production-valid `limit` is also valid here.
+		MaxLimit: 10000,
+		Timeout:  "10s",
 	}, nil
 }
 

internal/graphstore/memory_test.go

@@ -234,3 +234,18 @@ func relationPayload(src, dest, method string, first, last int64, fields map[str
 	}
 	return payload
 }
+
+// TestMemoryStoreMaxLimitNotBelowDefaultProvider guards query portability: the
+// memory store backs --quickstart / MCP / the demos, so a `limit` valid on the
+// default local.ladybug provider (MaxLimit 1000) must not be rejected here.
+// Memory itself caps higher (10000, in-memory headroom). Regression for
+// "query limit exceeds provider capability" when memory advertised MaxLimit 100.
+func TestMemoryStoreMaxLimitNotBelowDefaultProvider(t *testing.T) {
+	caps, err := NewMemoryStore().Capabilities(context.Background())
+	if err != nil {
+		t.Fatalf("capabilities: %v", err)
+	}
+	if caps.MaxLimit < 1000 {
+		t.Fatalf("memory MaxLimit = %d, want >= 1000 so production-valid limits stay portable", caps.MaxLimit)
+	}
+}