# refactor(import): add checkpoint.OpenImports helper to dedupe imports-store access

`d8df6e7`→[main](/content/gh/entireio/cli/commits/main/index.html)·

computermode·3w ago·8 files·+20 added/-22 removed

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

## Sessions

f2e9d10c5908View transcript

[?\
Implement Claude History Import FeatureClaude Code·Opus 4.8·3 steps](/content/gh/entireio/cli/session/897809d4-ecab-4dc6-aa21-97661cb62607#timeline-f2e9d10c5908/index.html)

## Changes

8

- cmd/entire/cli

- checkpoint

- Mopen.go+8/-2

- Mexplain.go+1/-2

- importclaude

- Mimporter.go+1/-3

- Mimporter\_test.go+2/-2

- Mrewind.go+1/-2

- Msetup\_import\_prompt\_test.go+1/-2

- strategy

- Mcommon.go+1/-2

- Mtokens\_profile.go+5/-7

```
31 unmodified lines

32
33
34
35
36
35
36
37
7 unmodified lines

45
46
47
48
49
50
51
52
53
54
55
56
57
58

31 unmodified lines

// Open resolves the checkpoint storage topology and constructs the backing
// store. It keeps ref resolution and blob-fetcher wiring in one place.
//
//nolint:unparam // Callers treat store construction as fallible at this boundary; the git backend has no fallible setup today.
func Open(ctx context.Context, repo *git.Repository, opts OpenOptions) (*Stores, error) {
	refs := resolveOpenRefs(ctx, opts)
	store := NewGitStore(repo, refs)
7 unmodified lines

}, nil
}

// OpenImports opens the local-only imports store (entire/imports/v1) used for
// read-only imported checkpoints. It is a thin convenience over Open with the
// imports ref topology, shared by every reader/writer of imported history.
func OpenImports(ctx context.Context, repo *git.Repository) (*Stores, error) {
	refs := ImportsRefs()
	return Open(ctx, repo, OpenOptions{Refs: &refs})
}

func resolveOpenRefs(ctx context.Context, opts OpenOptions) PersistentRefs {
	if opts.Refs != nil {
		return *opts.Refs
	}
}

Mcmd/entire/cli/checkpoint/open.go+8/-2

```
2169 unmodified lines

2170
2171
2172
2173
2174
2173
2174
2175
2176

2169 unmodified lines

// entire/imports/v1 as RewindPoint entries (flagged Imported, not rewindable).
// Best-effort: returns nil when the imports ref is absent or unreadable.
func getImportedRewindPoints(ctx context.Context, repo *git.Repository) []strategy.RewindPoint {
	importsRefs := checkpoint.ImportsRefs()
	stores, err := checkpoint.Open(ctx, repo, checkpoint.OpenOptions{Refs: &importsRefs})
	stores, err := checkpoint.OpenImports(ctx, repo)
	if err != nil {
		return nil
	}
}

Mcmd/entire/cli/explain.go+1/-2

```
44 unmodified lines

45
46
47
48
48
49
50
51
66 unmodified lines

118
119
120
121
122

44 unmodified lines

return res, err
	}

stores, err := cp.Open(ctx, repo, cp.OpenOptions{Refs: ptrRefs(cp.ImportsRefs())})
	stores, err := cp.OpenImports(ctx, repo)
	if err != nil {
		return res, fmt.Errorf("open imports store: %w", err)
	}
66 unmodified lines

}
	return nil
}

func ptrRefs(r cp.PersistentRefs) *cp.PersistentRefs { return &r }

Mcmd/entire/cli/importclaude/importer.go+1/-3

```
74 unmodified lines

75
76
77
78
78
79
80
81
35 unmodified lines

117
118
119
120
120
121
122
123

74 unmodified lines

t.Fatalf("re-run not idempotent: %+v", res2)
	}

stores, err := cp.Open(context.Background(), repo, cp.OpenOptions{Refs: ptrRefs(cp.ImportsRefs())})
	stores, err := cp.OpenImports(context.Background(), repo)
	if err != nil {
		t.Fatal(err)
	}
35 unmodified lines

t.Fatalf("dry-run should count 2 turns, got %+v", res)
	}

stores, err := cp.Open(context.Background(), repo, cp.OpenOptions{Refs: ptrRefs(cp.ImportsRefs())})
	stores, err := cp.OpenImports(context.Background(), repo)
	if err != nil {
		t.Fatal(err)
	}
```

Mcmd/entire/cli/importclaude/importer\_test.go+2/-2

```
422 unmodified lines

423
424
425
426
427
426
427
428
429

422 unmodified lines

}
	defer repo.Close()

importsRefs := checkpoint.ImportsRefs()
	stores, err := checkpoint.Open(ctx, repo, checkpoint.OpenOptions{Refs: &importsRefs})
	stores, err := checkpoint.OpenImports(ctx, repo)
	if err != nil {
		return nil
	}
```

Mcmd/entire/cli/rewind.go+1/-2

```
55 unmodified lines

56
57
58
59
60
59
60
61
62

55 unmodified lines

t.Fatal(err)
	}
	defer repo.Close()
	importsRefs := checkpoint.ImportsRefs()
	stores, err := checkpoint.Open(context.Background(), repo, checkpoint.OpenOptions{Refs: &importsRefs})
	stores, err := checkpoint.OpenImports(context.Background(), repo)
	if err != nil {
		t.Fatal(err)
	}
```

Mcmd/entire/cli/setup\_import\_prompt\_test.go+1/-2

```
353 unmodified lines

354
355
356
357
358
357
358
359
360

353 unmodified lines

}
	defer repo.Close()

importsRefs := checkpoint.ImportsRefs()
	imports, err := checkpoint.Open(ctx, repo, checkpoint.OpenOptions{Refs: &importsRefs})
	imports, err := checkpoint.OpenImports(ctx, repo)
	if err != nil {
		return base, nil
	}
```

Mcmd/entire/cli/strategy/common.go+1/-2

```
125 unmodified lines

126
127
128
129
130
131
132
133
134
135
129
130
131
132
133
134
135
136

125 unmodified lines

}
	// Include read-only imported checkpoints from entire/imports/v1, read from
	// their own store. Best-effort: skipped when the ref is absent.
	importsRefs := checkpoint.ImportsRefs()
	if importsStore := checkpoint.NewGitStore(repo, importsRefs); importsStore != nil {
		importsStore.SetBlobFetcher(FetchBlobsByHash)
		if importInfos, listErr := importsStore.List(ctx); listErr == nil {
			for _, info := range importInfos {
				refs = append(refs, tokensCheckpointRef{store: importsStore, info: info})
			}
		}
	}
	importsStore := checkpoint.NewGitStore(repo, checkpoint.ImportsRefs())
	importsStore.SetBlobFetcher(FetchBlobsByHash)
	if importInfos, listErr := importsStore.List(ctx); listErr == nil {
		for _, info := range importInfos {
			refs = append(refs, tokensCheckpointRef{store: importsStore, info: info})
		}
	}
```

Mcmd/entire/cli/tokens\_profile.go+5/-7