openAgent

1export * as FileSystemSearch from "./search"
2 
3import { makeLocationNode } from "../effect/app-node"
4import path from "path"
5import { Context, Effect, Layer, Scope } from "effect"
6import { Fff } from "#fff"
7import fuzzysort from "fuzzysort"
8import { FileSystem } from "../filesystem"
9import { FSUtil } from "../fs-util"
10import { Location } from "../location"
11import { Ripgrep } from "../ripgrep"
12import { RelativePath } from "../schema"
13import { Flag } from "../flag/flag"
14 
15export interface Interface {
16  readonly find: (input: FileSystem.FindInput) => Effect.Effect<FileSystem.Entry[]>
17  readonly glob: (input: FileSystem.GlobInput) => Effect.Effect<readonly FileSystem.Entry[]>
18  readonly grep: (input: FileSystem.GrepInput) => Effect.Effect<readonly FileSystem.Match[]>
19}
20 
21export class Service extends Context.Service<Service, Interface>()("@opencode/v2/FileSystem/Search") {}
22 
23export const ripgrepLayer = Layer.effect(
24  Service,
25  Effect.gen(function* () {
26    const fs = yield* FSUtil.Service
27    const location = yield* Location.Service
28    const ripgrep = yield* Ripgrep.Service
29    const scope = yield* Scope.Scope
30    const state = {
31      files: [] as string[],
32      directories: [] as string[],
33    }
34    const directories = new Set<string>()
35    yield* ripgrep
36      .find({
37        cwd: location.directory,
38        pattern: "*",
39        limit: location.vcs ? Number.MAX_SAFE_INTEGER : 100_000,
40        onEntry: (entry) =>
41          Effect.sync(() => {
42            state.files.push(entry.path)
43            const parts = entry.path.split("/")
44            parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path.sep))
45            state.directories = Array.from(directories)
46          }),
47      })
48      .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
49    return Service.of({
50      glob: (input) =>
51        Effect.gen(function* () {
52          const target = path.resolve(location.directory, input.path ?? ".")
53          const info = yield* fs.stat(target).pipe(Effect.orDie)
54          const cwd = info.type === "File" ? path.dirname(target) : target
55          return yield* ripgrep
56            .glob({
57              cwd,
58              pattern: input.pattern,
59              limit: input.limit ?? Number.MAX_SAFE_INTEGER,
60            })
61            .pipe(
62              Effect.map((result) =>
63                result.map((entry) =>
64                  FileSystem.Entry.make({
65                    ...entry,
66                    path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
67                  }),
68                ),
69              ),
70              Effect.orDie,
71            )
72        }),
73      grep: (input) =>
74        Effect.gen(function* () {
75          const target = path.resolve(location.directory, input.path ?? ".")
76          const info = yield* fs.stat(target).pipe(Effect.orDie)
77          const cwd = info.type === "File" ? path.dirname(target) : target
78          return yield* ripgrep
79            .grep({
80              cwd,
81              pattern: input.pattern,
82              file: info.type === "File" ? path.basename(target) : undefined,
83              include: input.include,
84              limit: input.limit ?? Number.MAX_SAFE_INTEGER,
85            })
86            .pipe(
87              Effect.map((result) =>
88                result.map((match) =>
89                  FileSystem.Match.make({
90                    ...match,
91                    entry: FileSystem.Entry.make({
92                      ...match.entry,
93                      path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path))),
94                    }),
95                  }),
96                ),
97              ),
98              Effect.orDie,
99            )
100        }),
101      find: (input) =>
102        Effect.gen(function* () {
103          const items =
104            input.type === "file"
105              ? state.files
106              : input.type === "directory"
107                ? state.directories
108                : [...state.files, ...state.directories]
109          return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
110            const relative = item.target
111            const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)
112            return FileSystem.Entry.make({
113              path: RelativePath.make(relative),
114              type,
115            })
116          })
117        }),
118    })
119  }),
120)
121 
122export const fffLayer = Layer.effect(
123  Service,
124  Effect.gen(function* () {
125    const location = yield* Location.Service
126    const result = yield* Effect.try({
127      try: () =>
128        Fff.create({
129          basePath: location.directory,
130          aiMode: true,
131          disableMmapCache: true,
132          disableContentIndexing: true,
133        }),
134      catch: (cause) => cause,
135    }).pipe(
136      Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))),
137    )
138    if (!result?.ok) {
139      if (result) yield* Effect.logWarning("failed to initialize fff", { error: result.error })
140      return Service.of({
141        find: () => Effect.succeed([]),
142        glob: () => Effect.succeed([]),
143        grep: () => Effect.succeed([]),
144      })
145    }
146    yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()).pipe(Effect.ignore))
147    return Service.of({
148      glob: (input) =>
149        Effect.sync(() => {
150          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
151          const found = result.value.glob(prefix ? `${prefix}/${input.pattern}` : input.pattern, {
152            pageIndex: 0,
153            pageSize: input.limit,
154          })
155          if (!found.ok) throw found.error
156          return found.value.items.map((item) =>
157            FileSystem.Entry.make({
158              path: RelativePath.make(item.relativePath.replaceAll("\\", "/")),
159              type: "file",
160            }),
161          )
162        }),
163      grep: (input) =>
164        Effect.sync(() => {
165          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
166          const found = result.value.grep(
167            [prefix ? `${prefix}/**` : undefined, input.include, input.pattern]
168              .filter((value) => value !== undefined)
169              .join(" "),
170            { mode: "regex", pageSize: input.limit, timeBudgetMs: 1_500 },
171          )
172          if (!found.ok) throw found.error
173          return found.value.items.map((match) => {
174            const bytes = Buffer.from(match.lineContent)
175            return FileSystem.Match.make({
176              entry: FileSystem.Entry.make({
177                path: RelativePath.make(match.relativePath.replaceAll("\\", "/")),
178                type: "file",
179              }),
180              line: match.lineNumber,
181              offset: match.byteOffset,
182              text: match.lineContent.length > 2_000 ? match.lineContent.slice(0, 2_000) + "..." : match.lineContent,
183              submatches: match.matchRanges.map(([start, end]) => ({
184                text: bytes.subarray(start, end).toString("utf8"),
185                start,
186                end,
187              })),
188            })
189          })
190        }),
191      find: (input) =>
192        Effect.sync(() => {
193          const options = { pageIndex: 0, pageSize: input.limit ?? 50 }
194          const items = (() => {
195            if (input.type === "file") {
196              const found = result.value.fileSearch(input.query.trim(), options)
197              if (!found.ok) throw found.error
198              return found.value.items.map((item, index) => ({
199                path: item.relativePath,
200                type: "file" as const,
201                score: found.value.scores[index]?.total ?? 0,
202              }))
203            }
204            if (input.type === "directory") {
205              const found = result.value.directorySearch(input.query.trim(), options)
206              if (!found.ok) throw found.error
207              return found.value.items.map((item, index) => ({
208                path: item.relativePath,
209                type: "directory" as const,
210                score: found.value.scores[index]?.total ?? 0,
211              }))
212            }
213            const found = result.value.mixedSearch(input.query.trim(), options)
214            if (!found.ok) throw found.error
215            return found.value.items.map((item, index) => ({
216              path: item.item.relativePath,
217              type: item.type,
218              score: found.value.scores[index]?.total ?? 0,
219            }))
220          })()
221          return items
222            .sort((a, b) => b.score - a.score || a.path.length - b.path.length)
223            .map((item) => {
224              const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "")
225              return FileSystem.Entry.make({
226                path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
227                type: item.type,
228              })
229            })
230        }),
231    })
232  }),
233)
234 
235const layer = Layer.unwrap(Effect.sync(() => (Flag.OPENCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)))
236 
237export const locationLayer = layer
238 
239export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Location.node, Ripgrep.node] })
240