diff --git a/frontend/components/DiffBlock.vue b/frontend/components/DiffBlock.vue
index 950f03b..15142d3 100644
--- a/frontend/components/DiffBlock.vue
+++ b/frontend/components/DiffBlock.vue
@@ -1,5 +1,5 @@
 <template>
-  <pre class="bg-gray-100"><code ref="code" :class="language">{{ diff }}</code></pre>
+  <pre class="bg-gray-100"><code ref="code" :class="language">{{ comment.diff_hunk }}</code></pre>
 </template>
 
 <script setup lang="ts">
@@ -32,43 +32,6 @@ const props = defineProps({
   },
 });
 
-// drop the first line of the diff since it's a diff hunk header
-const diff = computed(() => {
-  const comment = props.comment;
-
-  // let's get the lines first...
-  const lines = comment.diff_hunk.split("\n");
-
-  // the first line has metadata in it from the diff hunk...
-  // and we can get the starting line that's expected to be there
-  // from it...
-  const startCountingAt = parseInt(lines.shift().match(/@@ -(\d+),/)[1], 10);
-
-  // desiredRange 
-  const 
-    desiredStartLine = comment.start_line === undefined
-      ? comment.line - 4
-      : comment.start_line - (!startCountingAt ? 1 : 0),
-    desiredEndLine = comment.line,
-    outputDiff = [];
-
-
-  let lineNumber = startCountingAt;
-  lines.forEach(line => {
-    if (lineNumber >= desiredStartLine && lineNumber <= desiredEndLine) {
-      outputDiff.push(line);
-    }
-
-    if (comment.side == "LEFT" && !line.startsWith("+")) {
-      lineNumber++;
-    } else if (comment.side == "RIGHT" && !line.startsWith("-")) {
-      lineNumber++;
-    }
-  });
-
-  return outputDiff.join("\n");
-});
-
 // we grab the file extension and map it to the diff-language
 const languageMap = { rs: 'rust' };
 const language = computed(() => {
diff --git a/server/cmd/server-nuxt/api.go b/server/cmd/server-nuxt/api.go
index c4d8e8b..ba4b849 100644
--- a/server/cmd/server-nuxt/api.go
+++ b/server/cmd/server-nuxt/api.go
@@ -3,7 +3,7 @@ package main
 import (
 	"github.com/pkg/errors"
 
-	pm "github.com/stanistan/present-me"
+	"github.com/stanistan/present-me/internal/github"
 	"github.com/stanistan/present-me/internal/http"
 )
 
@@ -22,7 +22,7 @@ var apiRoutes = http.Routes(
 			return nil, errors.New("missing github context")
 		}
 
-		params, err := pm.ReviewParamsFromURL(r.URL.Query().Get("search"))
+		params, err := github.ReviewParamsFromURL(r.URL.Query().Get("search"))
 		if err != nil {
 			return nil, err
 		}
@@ -52,7 +52,7 @@ var apiRoutes = http.Routes(
 			return nil, errors.New("missing github context")
 		}
 
-		params, err := pm.ReviewParamsFromMap(pm.ReviewParamsMap{
+		params, err := github.ReviewParamsFromMap(github.ReviewParamsMap{
 			Owner:  values.Get("org"),
 			Repo:   values.Get("repo"),
 			Number: values.Get("pull"),
diff --git a/server/cmd/server-nuxt/main.go b/server/cmd/server-nuxt/main.go
index 3f50828..2655a56 100644
--- a/server/cmd/server-nuxt/main.go
+++ b/server/cmd/server-nuxt/main.go
@@ -11,16 +11,17 @@ import (
 
 	pm "github.com/stanistan/present-me"
 	"github.com/stanistan/present-me/internal/cache"
+	"github.com/stanistan/present-me/internal/github"
 )
 
 func main() {
 	var config pm.Config
 	_ = kong.Parse(&config)
 
-	config.Configure()
 	log := config.Logger()
+	diskCache := config.Cache(context.TODO())
 
-	gh, err := config.GH()
+	gh, err := config.GithubClient()
 	if err != nil {
 		log.Fatal().Err(err).Msg("could not configure GH client")
 	}
@@ -32,7 +33,7 @@ func main() {
 	api.Use(
 		hlog.NewHandler(log),
 		githubMiddleware(gh),
-		cacheMiddleware,
+		cacheMiddleware(diskCache),
 	)
 
 	for _, r := range apiRoutes {
@@ -65,16 +66,16 @@ type ghCtxKey int
 
 var ghCtxValue ghCtxKey
 
-func ContextWithGH(ctx context.Context, gh *pm.GH) context.Context {
+func ContextWithGH(ctx context.Context, gh *github.Client) context.Context {
 	return context.WithValue(ctx, ghCtxValue, gh)
 }
 
-func GHFromContext(ctx context.Context) (*pm.GH, bool) {
-	v, ok := ctx.Value(ghCtxValue).(*pm.GH)
+func GHFromContext(ctx context.Context) (*github.Client, bool) {
+	v, ok := ctx.Value(ghCtxValue).(*github.Client)
 	return v, ok
 }
 
-func githubMiddleware(g *pm.GH) func(http.Handler) http.Handler {
+func githubMiddleware(g *github.Client) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			ctx := ContextWithGH(r.Context(), g)
@@ -83,12 +84,15 @@ func githubMiddleware(g *pm.GH) func(http.Handler) http.Handler {
 	}
 }
 
-func cacheMiddleware(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ctx := cache.ContextWithOptions(r.Context(), &cache.Options{
-			TTL:          10 * time.Minute,
-			ForceRefresh: r.URL.Query().Get("refresh") == "1",
+func cacheMiddleware(c *cache.Cache) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := cache.ContextWithCache(r.Context(), c)
+			ctx = cache.ContextWithOptions(ctx, &cache.Options{
+				TTL:          10 * time.Minute,
+				ForceRefresh: r.URL.Query().Get("refresh") == "1",
+			})
+			next.ServeHTTP(w, r.WithContext(ctx))
 		})
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
+	}
 }
diff --git a/server/config.go b/server/config.go
index d2e9e77..e91c793 100644
--- a/server/config.go
+++ b/server/config.go
@@ -6,18 +6,19 @@ import (
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 
-	dc "github.com/stanistan/present-me/internal/cache"
+	"github.com/stanistan/present-me/internal/cache"
+	"github.com/stanistan/present-me/internal/github"
 	"github.com/stanistan/present-me/internal/log"
 )
 
 type Config struct {
 	ServeConfig
-	DiskCache dc.CacheOpts `embed:"" prefix:"disk-cache-"`
-	Github    GHOpts       `embed:"" prefix:"gh-"`
+	DiskCache cache.CacheOpts      `embed:"" prefix:"disk-cache-"`
+	Github    github.ClientOptions `embed:"" prefix:"gh-"`
 }
 
-func (c *Config) GH() (*GH, error) {
-	g, err := NewGH(c.Github)
+func (c *Config) GithubClient() (*github.Client, error) {
+	g, err := github.New(c.Github)
 	return g, errors.WithStack(err)
 }
 
@@ -25,17 +26,6 @@ func (c *Config) Logger() zerolog.Logger {
 	return log.NewLogger()
 }
 
-func (c *Config) Configure() {
-	configureCache(c.DiskCache)
+func (c *Config) Cache(ctx context.Context) *cache.Cache {
+	return cache.NewCache(ctx, c.DiskCache)
 }
-
-func configureCache(opts dc.CacheOpts) {
-	cache = dc.NewCache(context.TODO(), opts)
-}
-
-var (
-	cache *dc.Cache = dc.NewCache(
-		context.TODO(),
-		dc.CacheOpts{Enabled: false},
-	)
-)
diff --git a/server/github.go b/server/github.go
deleted file mode 100644
index 71282aa..0000000
--- a/server/github.go
+++ /dev/null
@@ -1,213 +0,0 @@
-package presentme
-
-import (
-	"context"
-	"net/http"
-	"sort"
-
-	"github.com/bradleyfalzon/ghinstallation/v2"
-	"github.com/google/go-github/v52/github"
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-
-	dc "github.com/stanistan/present-me/internal/cache"
-)
-
-type GHOpts struct {
-	AppID          int64        `name:"app_id" env:"GH_APP_ID" required:""`
-	InstallationID int64        `name:"installation_id" env:"GH_INSTALLATION_ID" required:""`
-	PrivateKey     GHPrivateKey `embed:"" prefix:"pk-" required:""`
-}
-
-type GHPrivateKey struct {
-	File string `name:"file" env:"GH_PK_FILE"`
-}
-
-func (o *GHOpts) HTTPClient() (*http.Client, error) {
-	var (
-		itr http.RoundTripper
-		err error
-	)
-
-	if o.PrivateKey.File != "" {
-		log.Info().Msgf("reading pk at path=%s", o.PrivateKey.File)
-		itr, err = ghinstallation.NewKeyFromFile(http.DefaultTransport, o.AppID, o.InstallationID, o.PrivateKey.File)
-	} else {
-		itr = http.DefaultTransport
-	}
-
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	log.Info().Msg("github client initialized")
-	return &http.Client{Transport: itr}, nil
-}
-
-type GH struct {
-	c *github.Client
-}
-
-func NewGH(opts GHOpts) (*GH, error) {
-	c, err := opts.HTTPClient()
-	if err != nil {
-		return nil, err
-	}
-
-	return &GH{c: github.NewClient(c)}, nil
-}
-
-func (g *GH) ListFiles(ctx context.Context, r *ReviewParams) ([]*github.CommitFile, error) {
-	var fs []*github.CommitFile
-	return fs, cache.Apply(ctx, &fs, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "files",
-			Hashing: []any{r.Owner, r.Repo, r.Number},
-		},
-		Fetch: func() (any, error) {
-			d, _, err := g.c.PullRequests.ListFiles(ctx, r.Owner, r.Repo, r.Number, nil)
-			return d, WrapGithubErr(err, "call to ListFiles failed")
-		},
-	})
-}
-
-func (g *GH) GetPullRequest(ctx context.Context, r *ReviewParams) (*github.PullRequest, error) {
-	var pr *github.PullRequest
-	return pr, cache.Apply(ctx, &pr, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "pr",
-			Hashing: []any{r.Owner, r.Repo, r.Number},
-		},
-		Fetch: func() (any, error) {
-			pr, _, err := g.c.PullRequests.Get(ctx, r.Owner, r.Repo, r.Number)
-			return pr, WrapGithubErr(err, "call to GetPullRequest failed")
-		},
-	})
-}
-
-func (g *GH) ListReviews(ctx context.Context, r *ReviewParams) ([]*github.PullRequestReview, error) {
-	var reviews []*github.PullRequestReview
-	return reviews, cache.Apply(ctx, &reviews, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "reviews",
-			Hashing: []any{r.Owner, r.Repo, r.Number},
-		},
-		Fetch: func() (any, error) {
-			reviews, _, err := g.c.PullRequests.ListReviews(ctx, r.Owner, r.Repo, r.Number, nil)
-			return reviews, WrapGithubErr(err, "call to ListReviews failed")
-		},
-	})
-}
-
-func (g *GH) GetReview(ctx context.Context, r *ReviewParams) (*github.PullRequestReview, error) {
-	var review *github.PullRequestReview
-	return review, cache.Apply(ctx, &review, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "review",
-			Hashing: []any{r.Owner, r.Repo, r.Number, r.ReviewID},
-		},
-		Fetch: func() (any, error) {
-			review, _, err := g.c.PullRequests.GetReview(ctx, r.Owner, r.Repo, r.Number, r.ReviewID)
-			return review, WrapGithubErr(err, "call to GetReview failed")
-		},
-	})
-}
-
-func (g *GH) ListReviewComments(ctx context.Context, r *ReviewParams) ([]*github.PullRequestComment, error) {
-	var cs []*github.PullRequestComment
-	return cs, cache.Apply(ctx, &cs, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "review-comments",
-			Hashing: []any{r.Owner, r.Repo, r.Number, r.ReviewID},
-		},
-		Fetch: func() (any, error) {
-			cs, _, err := g.c.PullRequests.ListReviewComments(ctx, r.Owner, r.Repo, r.Number, r.ReviewID, nil)
-			return cs, WrapGithubErr(err, "call to ListReviewComments failed")
-		},
-	})
-}
-
-func (g *GH) ListComments(ctx context.Context, r *ReviewParams) ([]*github.PullRequestComment, error) {
-	var cs []*github.PullRequestComment
-	err := cache.Apply(ctx, &cs, dc.Provider{
-		DataKey: dc.DataKey{
-			Prefix:  "pull-comments",
-			Hashing: []any{r.Owner, r.Repo, r.Number},
-		},
-		Fetch: func() (any, error) {
-			cs, _, err := g.c.PullRequests.ListComments(ctx, r.Owner, r.Repo, r.Number, nil)
-			return cs, WrapGithubErr(err, "call to ListComments failed")
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	var ret []*github.PullRequestComment
-	for _, c := range cs {
-		if c.PullRequestReviewID == nil || *c.PullRequestReviewID != r.ReviewID {
-			continue
-		}
-		ret = append(ret, c)
-	}
-
-	return ret, nil
-}
-
-func (g *GH) FetchReviewModel(ctx context.Context, r *ReviewParams) (*ReviewModel, error) {
-
-	pull, err := g.GetPullRequest(ctx, r)
-	if err != nil {
-		return nil, err
-	}
-
-	review, err := g.GetReview(ctx, r)
-	if err != nil {
-		return nil, err
-	}
-
-	comments, err := g.ListComments(ctx, r)
-	if err != nil {
-		return nil, err
-	}
-
-	annotatedFiles := map[string]struct{}{}
-	sort.Slice(comments, func(i, j int) bool {
-
-		annotatedFiles[*comments[i].Path] = struct{}{}
-		annotatedFiles[*comments[j].Path] = struct{}{}
-
-		c1, c1Ok := orderOf(*comments[i].Body)
-		c2, c2Ok := orderOf(*comments[j].Body)
-		if !c1Ok && !c2Ok {
-			return false
-		} else if !c1Ok {
-			return false
-		} else if !c2Ok {
-			return true
-		}
-		return c1 < c2
-	})
-
-	files, err := g.ListFiles(ctx, r)
-	if err != nil {
-		return nil, err
-	}
-
-	filesByPath := map[string]ReviewFile{}
-	for _, f := range files {
-		_, ok := annotatedFiles[*f.Filename]
-		filesByPath[*f.Filename] = ReviewFile{
-			IsAnnotated: ok,
-			File:        f,
-		}
-	}
-
-	return &ReviewModel{
-		Params:   r,
-		PR:       pull,
-		Review:   review,
-		Comments: comments,
-		Files:    filesByPath,
-	}, nil
-}
diff --git a/server/go.mod b/server/go.mod
index 1a8e52b..b91c3a5 100644
--- a/server/go.mod
+++ b/server/go.mod
@@ -13,6 +13,7 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.29.1
 	github.com/stretchr/testify v1.8.1
+	golang.org/x/sync v0.2.0
 )
 
 require (
diff --git a/server/go.sum b/server/go.sum
index 62f953d..441ebf8 100644
--- a/server/go.sum
+++ b/server/go.sum
@@ -87,6 +87,8 @@ golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.7.0 h1:qe6s0zUXlPX80/dITx3440hWZ7GwMwgDDyrSGTPJG/g=
 golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4=
+golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
+golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/server/internal/cache/context.go b/server/internal/cache/context.go
index 5f61751..f4b93d1 100644
--- a/server/internal/cache/context.go
+++ b/server/internal/cache/context.go
@@ -4,15 +4,34 @@ import (
 	"context"
 )
 
-type ctxKey int
-
-var ctxKeyVal ctxKey
+type ctxOptionsKey struct{}
 
 func ContextWithOptions(ctx context.Context, v *Options) context.Context {
-	return context.WithValue(ctx, ctxKeyVal, v)
+	return context.WithValue(ctx, ctxOptionsKey{}, v)
 }
 
 func OptionsFromContext(ctx context.Context) (*Options, bool) {
-	v, ok := ctx.Value(ctxKeyVal).(*Options)
+	v, ok := ctx.Value(ctxOptionsKey{}).(*Options)
 	return v, ok
 }
+
+type ctxCacheKey struct{}
+
+func ContextWithCache(ctx context.Context, c *Cache) context.Context {
+	return context.WithValue(ctx, ctxCacheKey{}, c)
+}
+
+var disabledCache *Cache = &Cache{disabled: true}
+
+func Ctx(ctx context.Context) *Cache {
+	v, ok := ctx.Value(ctxCacheKey{}).(*Cache)
+	if !ok {
+		return disabledCache
+	}
+
+	return v
+}
+
+func Apply(ctx context.Context, into any, p Provider) error {
+	return Ctx(ctx).Apply(ctx, into, p)
+}
diff --git a/server/errors.go b/server/internal/errors/errors.go
similarity index 94%
rename from server/errors.go
rename to server/internal/errors/errors.go
index ca6314a..3a55717 100644
--- a/server/errors.go
+++ b/server/internal/errors/errors.go
@@ -1,4 +1,4 @@
-package presentme
+package errors
 
 import (
 	"fmt"
@@ -25,6 +25,8 @@ func (e *Error) Unwrap() error {
 	return e.Cause
 }
 
+var WithStack = errors.WithStack
+
 func WrapGithubErr(e error, msg string, args ...interface{}) error {
 	if e == nil {
 		return nil
diff --git a/server/internal/github/github.go b/server/internal/github/github.go
new file mode 100644
index 0000000..ba3ed02
--- /dev/null
+++ b/server/internal/github/github.go
@@ -0,0 +1,238 @@
+package github
+
+import (
+	"context"
+	"net/http"
+	"sort"
+
+	"github.com/bradleyfalzon/ghinstallation/v2"
+	"github.com/google/go-github/v52/github"
+	"github.com/rs/zerolog/log"
+
+	"golang.org/x/sync/errgroup"
+
+	"github.com/stanistan/present-me/internal/cache"
+	"github.com/stanistan/present-me/internal/errors"
+)
+
+type ClientOptions struct {
+	AppID          int64      `name:"app_id" env:"GH_APP_ID" required:""`
+	InstallationID int64      `name:"installation_id" env:"GH_INSTALLATION_ID" required:""`
+	PrivateKey     PrivateKey `embed:"" prefix:"pk-" required:""`
+}
+
+type PrivateKey struct {
+	File string `name:"file" env:"GH_PK_FILE"`
+}
+
+func (o *ClientOptions) HTTPClient() (*http.Client, error) {
+	var (
+		itr http.RoundTripper
+		err error
+	)
+
+	if o.PrivateKey.File != "" {
+		log.Info().Msgf("reading pk at path=%s", o.PrivateKey.File)
+		itr, err = ghinstallation.NewKeyFromFile(http.DefaultTransport, o.AppID, o.InstallationID, o.PrivateKey.File)
+	} else {
+		itr = http.DefaultTransport
+	}
+
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	log.Info().Msg("github client initialized")
+	return &http.Client{Transport: itr}, nil
+}
+
+type Client struct {
+	c *github.Client
+}
+
+func New(opts ClientOptions) (*Client, error) {
+	c, err := opts.HTTPClient()
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{c: github.NewClient(c)}, nil
+}
+
+func (g *Client) ListFiles(ctx context.Context, r *ReviewParams) ([]*CommitFile, error) {
+	var fs []*CommitFile
+	return fs, cache.Ctx(ctx).Apply(ctx, &fs, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "files",
+			Hashing: []any{r.Owner, r.Repo, r.Number},
+		},
+		Fetch: func() (any, error) {
+			d, _, err := g.c.PullRequests.ListFiles(ctx, r.Owner, r.Repo, r.Number, nil)
+			return d, errors.WrapGithubErr(err, "call to ListFiles failed")
+		},
+	})
+}
+
+func (g *Client) GetPullRequest(ctx context.Context, r *ReviewParams) (*PullRequest, error) {
+	var pr *PullRequest
+	return pr, cache.Apply(ctx, &pr, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "pr",
+			Hashing: []any{r.Owner, r.Repo, r.Number},
+		},
+		Fetch: func() (any, error) {
+			pr, _, err := g.c.PullRequests.Get(ctx, r.Owner, r.Repo, r.Number)
+			return pr, errors.WrapGithubErr(err, "call to GetPullRequest failed")
+		},
+	})
+}
+
+func (g *Client) ListReviews(ctx context.Context, r *ReviewParams) ([]*PullRequestReview, error) {
+	var reviews []*PullRequestReview
+	return reviews, cache.Apply(ctx, &reviews, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "reviews",
+			Hashing: []any{r.Owner, r.Repo, r.Number},
+		},
+		Fetch: func() (any, error) {
+			reviews, _, err := g.c.PullRequests.ListReviews(ctx, r.Owner, r.Repo, r.Number, nil)
+			return reviews, errors.WrapGithubErr(err, "call to ListReviews failed")
+		},
+	})
+}
+
+func (g *Client) GetReview(ctx context.Context, r *ReviewParams) (*PullRequestReview, error) {
+	var review *PullRequestReview
+	return review, cache.Apply(ctx, &review, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "review",
+			Hashing: []any{r.Owner, r.Repo, r.Number, r.ReviewID},
+		},
+		Fetch: func() (any, error) {
+			review, _, err := g.c.PullRequests.GetReview(ctx, r.Owner, r.Repo, r.Number, r.ReviewID)
+			return review, errors.WrapGithubErr(err, "call to GetReview failed")
+		},
+	})
+}
+
+func (g *Client) ListReviewComments(ctx context.Context, r *ReviewParams) ([]*PullRequestComment, error) {
+	var cs []*PullRequestComment
+	return cs, cache.Apply(ctx, &cs, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "review-comments",
+			Hashing: []any{r.Owner, r.Repo, r.Number, r.ReviewID},
+		},
+		Fetch: func() (any, error) {
+			cs, _, err := g.c.PullRequests.ListReviewComments(ctx, r.Owner, r.Repo, r.Number, r.ReviewID, nil)
+			return cs, errors.WrapGithubErr(err, "call to ListReviewComments failed")
+		},
+	})
+}
+
+func (g *Client) ListComments(ctx context.Context, r *ReviewParams) ([]*PullRequestComment, error) {
+	var cs []*PullRequestComment
+	err := cache.Apply(ctx, &cs, cache.Provider{
+		DataKey: cache.DataKey{
+			Prefix:  "pull-comments",
+			Hashing: []any{r.Owner, r.Repo, r.Number},
+		},
+		Fetch: func() (any, error) {
+			cs, _, err := g.c.PullRequests.ListComments(ctx, r.Owner, r.Repo, r.Number, nil)
+			return cs, errors.WrapGithubErr(err, "call to ListComments failed")
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var ret []*PullRequestComment
+	for _, c := range cs {
+		if c.PullRequestReviewID == nil || *c.PullRequestReviewID != r.ReviewID {
+			continue
+		}
+		ret = append(ret, c)
+	}
+
+	return ret, nil
+}
+
+func (g *Client) FetchReviewModel(ctx context.Context, r *ReviewParams) (*ReviewModel, error) {
+	model := &ReviewModel{Params: r}
+	group, ctx := errgroup.WithContext(ctx)
+
+	group.Go(func() error {
+		pull, err := g.GetPullRequest(ctx, r)
+		if err == nil {
+			model.PR = pull
+		}
+		return err
+	})
+
+	group.Go(func() error {
+		review, err := g.GetReview(ctx, r)
+		if err == nil {
+			model.Review = review
+		}
+		return err
+	})
+
+	group.Go(func() error {
+		comments, err := g.ListComments(ctx, r)
+		if err == nil {
+			for idx, comment := range comments {
+				diff, err := generateDiff(comment)
+				if err != nil {
+					return err
+				}
+				comment.DiffHunk = &diff
+				comments[idx] = comment
+			}
+			model.Comments = comments
+		}
+		return err
+	})
+
+	group.Go(func() error {
+		files, err := g.ListFiles(ctx, r)
+		if err == nil {
+			filesByPath := map[string]ReviewFile{}
+			for _, f := range files {
+				filesByPath[*f.Filename] = ReviewFile{
+					IsAnnotated: false,
+					File:        f,
+				}
+			}
+
+			model.Files = filesByPath
+		}
+		return err
+	})
+
+	err := group.Wait()
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Slice(model.Comments, func(i, j int) bool {
+		path := *model.Comments[i].Path
+		if file, exists := model.Files[path]; exists {
+			model.Files[path] = ReviewFile{
+				File:        file.File,
+				IsAnnotated: true,
+			}
+		}
+
+		c1, c1Ok := orderOf(*model.Comments[i].Body)
+		c2, c2Ok := orderOf(*model.Comments[j].Body)
+		if !c1Ok && !c2Ok {
+			return false
+		} else if !c1Ok {
+			return false
+		} else if !c2Ok {
+			return true
+		}
+		return c1 < c2
+	})
+
+	return model, nil
+}
diff --git a/server/params_test.go b/server/internal/github/params_test.go
similarity index 93%
rename from server/params_test.go
rename to server/internal/github/params_test.go
index d5216c2..029ae26 100644
--- a/server/params_test.go
+++ b/server/internal/github/params_test.go
@@ -1,4 +1,4 @@
-package presentme
+package github
 
 import (
 	"testing"
diff --git a/server/internal/github/review_model.go b/server/internal/github/review_model.go
new file mode 100644
index 0000000..e826ab1
--- /dev/null
+++ b/server/internal/github/review_model.go
@@ -0,0 +1,126 @@
+package github
+
+import (
+	"bufio"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/stanistan/present-me/internal/errors"
+)
+
+type ReviewModel struct {
+	Params *ReviewParams `json:"params"`
+
+	PR       *PullRequest          `json:"pr"`
+	Review   *PullRequestReview    `json:"review"`
+	Comments []*PullRequestComment `json:"comments"`
+	Files    map[string]ReviewFile `json:"files"`
+}
+
+type ReviewFile struct {
+	IsAnnotated bool        `json:"isAnnotated"`
+	File        *CommitFile `json:"file"`
+}
+
+var startsWithNumberRegexp = regexp.MustCompile(`^\s*(\d+)\.\s*`)
+
+func orderOf(c string) (int, bool) {
+	m := startsWithNumberRegexp.FindStringSubmatch(c)
+	if m == nil {
+		return 0, false
+	}
+
+	n, _ := strconv.Atoi(m[1])
+	return n, true
+}
+
+func generateDiff(comment *PullRequestComment) (string, error) {
+	//
+	// 1. we extract the metadata, so we know which side we are going to be starting
+	//    on.
+	meta, err := diffHunkPrefix(*comment.DiffHunk)
+	if err != nil {
+		return "", errors.WithStack(err)
+	}
+
+	//
+	// 2.
+	//
+	// - using the meta, we can see what the first line of the hunk is.
+	// - depending on if we're doing LEFT or RIGHT, it means we will
+	//   count (or not) specific lines when deciding which ones to include
+	//   or not.
+	var countFrom int
+	var countLinesNotStartingWith string
+	switch *comment.Side {
+	case "LEFT":
+		countFrom = meta.Left
+		countLinesNotStartingWith = "+"
+	case "RIGHT":
+		countFrom = meta.Right
+		countLinesNotStartingWith = "-"
+	}
+
+	//
+	// 3.
+	//
+	// - endLine is the line that the comment is on or after,
+	// - startLine is the beginning line that we'll include in our diff,
+	//   and it looks like github defaults to 4 lines included if there is
+	//   no `StartLine`.
+	var endLine = *comment.Line
+	var startLine int
+	if comment.StartLine == nil {
+		startLine = endLine - 3
+	} else {
+		startLine = *comment.StartLine
+	}
+
+	//
+	// 4.
+	//
+	// Ok, so we're now ready to start going through the _input_ diff
+	// line by line.
+	var idx = countFrom
+	var lines = bufio.NewScanner(strings.NewReader(*comment.DiffHunk))
+	var out strings.Builder
+
+	// drop the first line, since it has the metadata in it (we parsed it above).
+	lines.Scan()
+
+	// actually go through line by line, keeping the diff range we want
+	// from this hunk.
+	for lines.Scan() {
+		line := lines.Text()
+		if idx >= startLine && idx <= endLine {
+			out.WriteString(line + "\n")
+		}
+
+		if !strings.HasPrefix(line, countLinesNotStartingWith) {
+			idx++
+		}
+	}
+
+	// and join our string!
+	return out.String(), nil
+}
+
+type diffHunkMetadata struct {
+	Left, Right int
+}
+
+var diffHunkPrefixRegexp = regexp.MustCompile(`^@@ -(\d+),\d+ \+(\d+),\d+ @@`)
+
+func diffHunkPrefix(hunk string) (diffHunkMetadata, error) {
+	meta := diffHunkMetadata{}
+	m := diffHunkPrefixRegexp.FindStringSubmatch(hunk)
+	if m == nil {
+		return meta, fmt.Errorf("could not parse hunk prefix")
+	}
+
+	meta.Left, _ = strconv.Atoi(m[1])
+	meta.Right, _ = strconv.Atoi(m[2])
+	return meta, nil
+}
diff --git a/server/internal/github/review_model_test.go b/server/internal/github/review_model_test.go
new file mode 100644
index 0000000..0ec0183
--- /dev/null
+++ b/server/internal/github/review_model_test.go
@@ -0,0 +1,24 @@
+package github
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseDiffHunkPrefix(t *testing.T) {
+	t.Run("first case", func(t *testing.T) {
+		meta, err := diffHunkPrefix("@@ -230,6 +200,9 @@ if (!defined $initial_reply_to && $prompting) {")
+		require.NoError(t, err)
+		require.Equal(t, diffHunkMetadata{230, 200}, meta)
+	})
+	t.Run("succeeds", func(t *testing.T) {
+		meta, err := diffHunkPrefix("@@ -0,6 +200,9 @@ if (!defined $initial_reply_to && $prompting) {")
+		require.NoError(t, err)
+		require.Equal(t, diffHunkMetadata{0, 200}, meta)
+	})
+	t.Run("errs", func(t *testing.T) {
+		_, err := diffHunkPrefix("@@ -0,6 +a,9 @@ if (!defined $initial_reply_to && $prompting) {")
+		require.Error(t, err)
+	})
+}
diff --git a/server/params.go b/server/internal/github/review_params.go
similarity index 94%
rename from server/params.go
rename to server/internal/github/review_params.go
index c094dde..cd2b601 100644
--- a/server/params.go
+++ b/server/internal/github/review_params.go
@@ -1,4 +1,4 @@
-package presentme
+package github
 
 import (
 	"context"
@@ -95,11 +95,11 @@ func ReviewParamsFromMap(m ReviewParamsMap) (*ReviewParams, error) {
 	}, nil
 }
 
-func (r *ReviewParams) Model(ctx context.Context, g *GH) (*ReviewModel, error) {
+func (r *ReviewParams) Model(ctx context.Context, g *Client) (*ReviewModel, error) {
 	return g.FetchReviewModel(ctx, r)
 }
 
-func (r *ReviewParams) EnsureReviewID(ctx context.Context, g *GH) (bool, error) {
+func (r *ReviewParams) EnsureReviewID(ctx context.Context, g *Client) (bool, error) {
 	if r.ReviewID != 0 {
 		return false, nil
 	}
diff --git a/server/internal/github/types.go b/server/internal/github/types.go
new file mode 100644
index 0000000..096dab9
--- /dev/null
+++ b/server/internal/github/types.go
@@ -0,0 +1,10 @@
+package github
+
+import "github.com/google/go-github/v52/github"
+
+type (
+	PullRequest        = github.PullRequest
+	PullRequestReview  = github.PullRequestReview
+	PullRequestComment = github.PullRequestComment
+	CommitFile         = github.CommitFile
+)
diff --git a/server/model.go b/server/model.go
deleted file mode 100644
index c5a8e49..0000000
--- a/server/model.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package presentme
-
-import (
-	"regexp"
-	"strconv"
-
-	"github.com/google/go-github/v52/github"
-)
-
-type ReviewModel struct {
-	Params *ReviewParams `json:"params"`
-
-	PR       *github.PullRequest          `json:"pr"`
-	Review   *github.PullRequestReview    `json:"review"`
-	Comments []*github.PullRequestComment `json:"comments"`
-	Files    map[string]ReviewFile        `json:"files"`
-}
-
-type ReviewFile struct {
-	IsAnnotated bool               `json:"isAnnotated"`
-	File        *github.CommitFile `json:"file"`
-}
-
-var startsWithNumberRegexp = regexp.MustCompile(`^\s*(\d+)\.\s*`)
-
-func orderOf(c string) (int, bool) {
-	m := startsWithNumberRegexp.FindStringSubmatch(c)
-	if m == nil {
-		return 0, false
-	}
-
-	n, _ := strconv.Atoi(m[1])
-	return n, true
-}