openAgent

1export * as Snapshot from "./snapshot"
2 
3import { makeLocationNode } from "./effect/app-node"
4import path from "path"
5import { Context, Effect, Layer, Schema } from "effect"
6import { Config } from "./config"
7import { File } from "./file"
8import { FSUtil } from "./fs-util"
9import { Git } from "./git"
10import { Global } from "./global"
11import { Location } from "./location"
12import { AbsolutePath, RelativePath } from "./schema"
13import { Hash } from "./util/hash"
14 
15export const ID = Schema.String.pipe(Schema.brand("Snapshot.ID"))
16export type ID = typeof ID.Type
17 
18export class Error extends Schema.TaggedErrorClass<Error>()("Snapshot.Error", {
19  operation: Schema.Literals(["capture", "files", "diff", "preview", "restore"]),
20  message: Schema.String,
21  cause: Schema.optional(Schema.Defect()),
22}) {}
23 
24export interface CompareInput {
25  readonly from: ID
26  readonly to: ID
27}
28 
29export interface DiffInput extends CompareInput {
30  readonly context?: number
31  readonly paths?: readonly RelativePath[]
32}
33 
34export interface RestoreInput {
35  /** Paths are relative to the project root. */
36  readonly files: ReadonlyMap<RelativePath, ID>
37}
38 
39export interface PreviewInput extends RestoreInput {
40  readonly context?: number
41}
42 
43export interface Interface {
44  /**
45   * Capture the current Location-scoped filesystem state as a content-addressed
46   * tree. Returns `undefined` when snapshots are disabled, unsupported, or the
47   * best-effort capture fails.
48   */
49  readonly capture: () => Effect.Effect<ID | undefined>
50 
51  /**
52   * List project-relative paths changed between two captured trees without
53   * loading file contents or generating patches.
54   */
55  readonly files: (input: CompareInput) => Effect.Effect<readonly RelativePath[], Error>
56 
57  /**
58   * Generate structured per-file diffs between two captured trees. `context`
59   * controls unchanged lines around each unified diff hunk.
60   */
61  readonly diff: (input: DiffInput) => Effect.Effect<readonly File.Diff[], Error>
62 
63  /**
64   * Preview the filesystem result of a selective restore without modifying the
65   * worktree. Each project-relative path maps to the tree it would be restored
66   * from.
67   */
68  readonly preview: (input: PreviewInput) => Effect.Effect<readonly File.Diff[], Error>
69 
70  /**
71   * Restore selected project-relative paths from their associated trees. A path
72   * absent from its selected tree is removed; paths outside the map are untouched.
73   */
74  readonly restore: (input: RestoreInput) => Effect.Effect<void, Error>
75 
76  /**
77   * Replace the snapshot index with a captured tree and check out all its entries.
78   * Files absent from the tree remain untouched. Prefer selective `restore` when
79   * only known paths should change.
80   */
81  readonly checkout: (snapshot: ID) => Effect.Effect<void, Error>
82}
83 
84export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Snapshot") {}
85 
86const layer = Layer.effect(
87  Service,
88  Effect.gen(function* () {
89    const config = yield* Config.Service
90    const fs = yield* FSUtil.Service
91    const git = yield* Git.Service
92    const global = yield* Global.Service
93    const location = yield* Location.Service
94    const source = yield* git.repo.discover(location.project.directory)
95    const worktree = source
96      ? AbsolutePath.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie))
97      : location.project.directory
98    const gitDirectory = AbsolutePath.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)))
99 
100    const scope = Effect.fnUntraced(function* () {
101      const relative = path.relative(worktree, location.directory)
102      if (relative.startsWith("..") || path.isAbsolute(relative))
103        return yield* new Error({ operation: "capture", message: "Location is outside the project" })
104      return RelativePath.make(relative.replaceAll("\\", "/") || ".")
105    })
106 
107    const repository = Effect.fnUntraced(function* () {
108      if (!source) return yield* new Error({ operation: "capture", message: "Project is not a Git repository" })
109      if (yield* fs.existsSafe(path.join(gitDirectory, "HEAD")))
110        return new Git.Repository({
111          worktree,
112          gitDirectory,
113          commonDirectory: gitDirectory,
114        })
115      return yield* git.repo
116        .create({
117          worktree,
118          gitDirectory,
119          seed: source,
120        })
121        .pipe(Effect.mapError((cause) => failure("capture", cause)))
122    })
123 
124    const enabled = Effect.fnUntraced(function* () {
125      if (location.vcs?.type !== "git") return false
126      return Config.latest(yield* config.entries(), "snapshots") !== false
127    })
128 
129    const capture = Effect.fn("Snapshot.capture")(function* () {
130      if (!(yield* enabled())) return undefined
131      return yield* Effect.gen(function* () {
132        const repo = yield* repository()
133        return ID.make(
134          yield* git.tree.capture({
135            repository: repo,
136            scopes: [yield* scope()],
137            ignores: source,
138            maximumUntrackedFileBytes: 2 * 1024 * 1024,
139          }),
140        )
141      }).pipe(
142        Effect.catch((cause) => Effect.logWarning("failed to capture snapshot", { cause }).pipe(Effect.as(undefined))),
143      )
144    })
145 
146    const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
147      const repo = yield* repository().pipe(Effect.mapError((cause) => failure(operation, cause)))
148      return { repository: repo, from: Git.TreeID.make(input.from), to: Git.TreeID.make(input.to) }
149    })
150 
151    const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
152      const comparison = yield* compare("files", input)
153      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure("files", cause)))
154      if (!source) return files
155      const ignored = yield* git.index
156        .ignored({ repository: source, paths: files })
157        .pipe(Effect.mapError((cause) => failure("files", cause)))
158      return files.filter((file) => !ignored.has(file))
159    })
160 
161    const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
162      const comparison = yield* compare("diff", input)
163      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure("diff", cause)))
164      const ignored = source
165        ? yield* git.index
166            .ignored({ repository: source, paths: files })
167            .pipe(Effect.mapError((cause) => failure("diff", cause)))
168        : new Set<RelativePath>()
169      return yield* git.tree
170        .diff({
171          ...comparison,
172          context: input.context,
173          paths: (input.paths ?? files).filter((file) => !ignored.has(file)),
174        })
175        .pipe(Effect.mapError((cause) => failure("diff", cause)))
176    })
177 
178    const plan = Effect.fnUntraced(function* (operation: "preview" | "restore", input: RestoreInput) {
179      const files = new Map<RelativePath, Git.TreeID>()
180      for (const [file, snapshot] of input.files) {
181        const absolute = path.resolve(worktree, file)
182        if (!FSUtil.contains(worktree, absolute))
183          return yield* new Error({ operation, message: `Path escapes the project: ${file}` })
184        files.set(file, Git.TreeID.make(snapshot))
185      }
186      return files
187    })
188 
189    const preview = Effect.fn("Snapshot.preview")(function* (input: PreviewInput) {
190      if (!(yield* enabled())) return yield* new Error({ operation: "preview", message: "Snapshots are disabled" })
191      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("preview", cause)))
192      const files = yield* plan("preview", input)
193      const current = yield* git.tree
194        .capture({
195          repository: repo,
196          scopes: Array.from(files.keys()),
197          ignores: source,
198          maximumUntrackedFileBytes: 2 * 1024 * 1024,
199        })
200        .pipe(Effect.mapError((cause) => failure("preview", cause)))
201      return yield* git.tree
202        .preview({
203          repository: repo,
204          current,
205          files,
206          context: input.context,
207        })
208        .pipe(Effect.mapError((cause) => failure("preview", cause)))
209    })
210 
211    const restore = Effect.fn("Snapshot.restore")(function* (input: RestoreInput) {
212      if (!(yield* enabled())) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
213      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("restore", cause)))
214      yield* git.tree
215        .restore({ repository: repo, files: yield* plan("restore", input) })
216        .pipe(Effect.mapError((cause) => failure("restore", cause)))
217    })
218 
219    const checkout = Effect.fn("Snapshot.checkout")(function* (snapshot: ID) {
220      const repo = yield* repository().pipe(Effect.mapError((cause) => failure("restore", cause)))
221      yield* git.tree
222        .checkout({ repository: repo, tree: Git.TreeID.make(snapshot) })
223        .pipe(Effect.mapError((cause) => failure("restore", cause)))
224    })
225 
226    return Service.of({ capture, files, diff, preview, restore, checkout })
227  }),
228)
229 
230export const locationLayer = layer.pipe(Layer.provideMerge(Config.locationLayer))
231 
232export const node = makeLocationNode({
233  service: Service,
234  layer,
235  deps: [Config.node, FSUtil.node, Git.node, Global.node, Location.node],
236})
237 
238export const noopLayer = Layer.succeed(
239  Service,
240  Service.of({
241    capture: () => Effect.succeed(undefined),
242    files: () => Effect.succeed([]),
243    diff: () => Effect.succeed([]),
244    preview: () => Effect.succeed([]),
245    restore: () => Effect.void,
246    checkout: () => Effect.void,
247  }),
248)
249 
250function failure(operation: Error["operation"], cause: unknown) {
251  if (cause instanceof Error && cause.operation === operation) return cause
252  return new Error({
253    operation,
254    message: cause instanceof globalThis.Error ? cause.message : String(cause),
255    cause,
256  })
257}
258 
259/** Legacy persisted session diff shape. */
260export type LegacyFileDiff = {
261  file?: string
262  patch?: string
263  additions: number
264  deletions: number
265  status?: "added" | "deleted" | "modified"
266}
267