refactor(core): unify filesystem search service (#31566)

packages/core/src/filesystem.ts

@@ -6,8 +6,10 @@ import { Context, Effect, Layer, Option, Schema } from "effect"
 import { EventV2 } from "./event"
 import { FSUtil } from "./fs-util"
 import { Location } from "./location"
-import { NonNegativeInt, PositiveInt, RelativePath } from "./schema"
-import { Search } from "./filesystem/search"
+import { PositiveInt, RelativePath } from "./schema"
+import { FileSystemSearch } from "./filesystem/search"
+import { Entry, Match } from "./filesystem/schema"
+export { Entry, Match, Submatch } from "./filesystem/schema"
 
 export const ReadInput = Schema.Struct({
   path: RelativePath,
@@ -28,39 +30,23 @@ export const ListInput = Schema.Struct({
 })
 export type ListInput = typeof ListInput.Type
 
-export class Entry extends Schema.Class<Entry>("FileSystem.Entry")({
-  path: RelativePath,
-  uri: Schema.String,
-  type: Schema.Literals(["file", "directory"]),
-  mime: Schema.String,
-}) {}
-
-export const FindInput = Schema.Struct({
+export class FindInput extends Schema.Class<FindInput>("FileSystem.FindInput")({
   query: Schema.String,
   type: Schema.Literals(["file", "directory"]).pipe(Schema.optional),
   limit: PositiveInt.pipe(Schema.optional),
-})
-export type FindInput = typeof FindInput.Type
+}) {}
 
-export const GrepInput = Schema.Struct({
+export class GlobInput extends Schema.Class<GlobInput>("FileSystem.GlobInput")({
   pattern: Schema.String,
+  path: RelativePath.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+}) {}
+
+export class GrepInput extends Schema.Class<GrepInput>("FileSystem.GrepInput")({
+  pattern: Schema.String,
+  path: RelativePath.pipe(Schema.optional),
   include: Schema.String.pipe(Schema.optional),
   limit: PositiveInt.pipe(Schema.optional),
-})
-export type GrepInput = typeof GrepInput.Type
-
-export class GrepMatch extends Schema.Class<GrepMatch>("LocationFileSystem.GrepMatch")({
-  path: RelativePath,
-  lines: Schema.String,
-  line: PositiveInt,
-  offset: NonNegativeInt,
-  submatches: Schema.Array(
-    Schema.Struct({
-      text: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
 }) {}
 
 export const Event = {
@@ -76,17 +62,18 @@ export interface Interface {
   readonly read: (input: ReadInput) => Effect.Effect<Content>
   readonly list: (input?: ListInput) => Effect.Effect<Entry[]>
   readonly find: (input: FindInput) => Effect.Effect<Entry[]>
-  readonly grep: (input: GrepInput) => Effect.Effect<GrepMatch[]>
+  readonly glob: (input: GlobInput) => Effect.Effect<readonly Entry[]>
+  readonly grep: (input: GrepInput) => Effect.Effect<readonly Match[]>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/FileSystem") {}
 
-export const layer = Layer.effect(
+const baseLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
-    const search = yield* Search.Service
+    const search = yield* FileSystemSearch.Service
     const root = yield* fs.realPath(location.directory).pipe(Effect.orDie)
     const resolve = Effect.fnUntraced(function* (input?: RelativePath) {
       const absolute = path.resolve(location.directory, input ?? ".")
@@ -96,22 +83,10 @@ export const layer = Layer.effect(
       if (!FSUtil.contains(root, real)) return yield* Effect.die(new Error("Path escapes the location"))
       return { absolute, real, directory: location.directory, root }
     })
-    const entry = Effect.fnUntraced(function* (absolute: string, selected = { directory: location.directory, root }) {
-      const real = yield* fs.realPath(absolute).pipe(Effect.catch(() => Effect.void))
-      if (!real) return
-      if (!FSUtil.contains(selected.root, real)) return
-      const info = yield* fs.stat(real).pipe(Effect.catch(() => Effect.void))
-      const type = info?.type === "Directory" ? "directory" : info?.type === "File" ? "file" : undefined
-      if (!type) return
-      return new Entry({
-        path: RelativePath.make(path.relative(selected.directory, absolute)),
-        uri: pathToFileURL(real).href,
-        type,
-        mime: type === "directory" ? "application/x-directory" : FSUtil.mimeType(real),
-      })
-    })
-
     return Service.of({
+      find: search.find,
+      glob: search.glob,
+      grep: search.grep,
       read: Effect.fn("FileSystem.read")(function* (input) {
         const target = yield* resolve(input.path)
         const info = yield* fs.stat(target.real).pipe(Effect.orDie)
@@ -145,62 +120,28 @@ export const layer = Layer.effect(
         if (info.type !== "Directory") return yield* Effect.die(new Error("Path is not a directory"))
         return yield* fs.readDirectoryEntries(target.real).pipe(
           Effect.orDie,
-          Effect.flatMap((items) =>
-            Effect.forEach(items, (item) => entry(path.join(target.absolute, item.name), target), {
-              concurrency: "unbounded",
-            }),
-          ),
           Effect.map((items) =>
             items
-              .filter((item): item is Entry => item !== undefined)
+              .flatMap((item) => {
+                if (item.type !== "file" && item.type !== "directory") return []
+                const absolute = path.join(target.absolute, item.name)
+                const relative = path.relative(target.directory, absolute)
+                return [
+                  new Entry({
+                    path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+                    type: item.type,
+                    mime: item.type === "directory" ? "application/x-directory" : FSUtil.mimeType(absolute),
+                  }),
+                ]
+              })
               .sort((a, b) => (a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1)),
           ),
         )
       }),
-      find: Effect.fn("FileSystem.find")(function* (input) {
-        const found = yield* search
-          .file({
-            cwd: location.directory,
-            query: input.query,
-            limit: input.limit,
-            kind: input.type ?? "all",
-          })
-          .pipe(Effect.orDie)
-        return found.map(
-          (item) =>
-            new Entry({
-              path: RelativePath.make(item.path),
-              uri: pathToFileURL(path.join(location.directory, item.path)).href,
-              type: item.type,
-              mime: item.type === "directory" ? "application/x-directory" : FSUtil.mimeType(item.path),
-            }),
-        )
-      }),
-      grep: Effect.fn("FileSystem.grep")(function* (input) {
-        return (yield* search
-          .search({
-            cwd: location.directory,
-            pattern: input.pattern,
-            glob: input.include ? [input.include] : undefined,
-            limit: input.limit,
-          })
-          .pipe(Effect.orDie)).items.map(
-          (item) =>
-            new GrepMatch({
-              path: RelativePath.make(item.path.text),
-              lines: item.lines.text,
-              line: item.line_number,
-              offset: item.absolute_offset,
-              submatches: item.submatches.map((submatch) => ({
-                text: submatch.match.text,
-                start: submatch.start,
-                end: submatch.end,
-              })),
-            }),
-        )
-      }),
     })
   }),
 )
 
+export const layer = baseLayer.pipe(Layer.provide(FileSystemSearch.defaultLayer), Layer.provide(FSUtil.defaultLayer))
+
 export const locationLayer = layer