@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/file/protected.ts

@@ -1,59 +0,0 @@
-import path from "path"
-import os from "os"
-
-const home = os.homedir()
-
-// macOS directories that trigger TCC (Transparency, Consent, and Control)
-// permission prompts when accessed by a non-sandboxed process.
-const DARWIN_HOME = [
-  // Media
-  "Music",
-  "Pictures",
-  "Movies",
-  // User-managed folders synced via iCloud / subject to TCC
-  "Downloads",
-  "Desktop",
-  "Documents",
-  // Other system-managed
-  "Public",
-  "Applications",
-  "Library",
-]
-
-const DARWIN_LIBRARY = [
-  "Application Support/AddressBook",
-  "Calendars",
-  "Mail",
-  "Messages",
-  "Safari",
-  "Cookies",
-  "Application Support/com.apple.TCC",
-  "PersonalizationPortrait",
-  "Metadata/CoreSpotlight",
-  "Suggestions",
-]
-
-const DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"]
-
-const WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"]
-
-/** Directory basenames to skip when scanning the home directory. */
-export function names(): ReadonlySet<string> {
-  if (process.platform === "darwin") return new Set(DARWIN_HOME)
-  if (process.platform === "win32") return new Set(WIN32_HOME)
-  return new Set()
-}
-
-/** Absolute paths that should never be watched, stated, or scanned. */
-export function paths(): string[] {
-  if (process.platform === "darwin")
-    return [
-      ...DARWIN_HOME.map((n) => path.join(home, n)),
-      ...DARWIN_LIBRARY.map((n) => path.join(home, "Library", n)),
-      ...DARWIN_ROOT,
-    ]
-  if (process.platform === "win32") return WIN32_HOME.map((n) => path.join(home, n))
-  return []
-}
-
-export * as Protected from "./protected"

package/src/file/ripgrep.ts

@@ -1,485 +0,0 @@
-import path from "path"
-import z from "zod"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { Cause, Context, Effect, Fiber, Layer, Queue, Stream } from "effect"
-import type { PlatformError } from "effect/PlatformError"
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
-import { ChildProcess } from "effect/unstable/process"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-
-import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
-import { Global } from "@/global"
-import { Log } from "@/util"
-import { sanitizedProcessEnv } from "@/util/sleepy-process"
-import { which } from "@/util/which"
-
-const log = Log.create({ service: "ripgrep" })
-const VERSION = "15.1.0"
-const PLATFORM = {
-  "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
-  "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
-  "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
-  "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
-  "arm64-win32": { platform: "aarch64-pc-windows-msvc", extension: "zip" },
-  "ia32-win32": { platform: "i686-pc-windows-msvc", extension: "zip" },
-  "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
-} as const
-
-const Stats = z.object({
-  elapsed: z.object({
-    secs: z.number(),
-    nanos: z.number(),
-    human: z.string(),
-  }),
-  searches: z.number(),
-  searches_with_match: z.number(),
-  bytes_searched: z.number(),
-  bytes_printed: z.number(),
-  matched_lines: z.number(),
-  matches: z.number(),
-})
-
-const Begin = z.object({
-  type: z.literal("begin"),
-  data: z.object({
-    path: z.object({
-      text: z.string(),
-    }),
-  }),
-})
-
-export const Match = z.object({
-  type: z.literal("match"),
-  data: z.object({
-    path: z.object({
-      text: z.string(),
-    }),
-    lines: z.object({
-      text: z.string(),
-    }),
-    line_number: z.number(),
-    absolute_offset: z.number(),
-    submatches: z.array(
-      z.object({
-        match: z.object({
-          text: z.string(),
-        }),
-        start: z.number(),
-        end: z.number(),
-      }),
-    ),
-  }),
-})
-
-const End = z.object({
-  type: z.literal("end"),
-  data: z.object({
-    path: z.object({
-      text: z.string(),
-    }),
-    binary_offset: z.number().nullable(),
-    stats: Stats,
-  }),
-})
-
-const Summary = z.object({
-  type: z.literal("summary"),
-  data: z.object({
-    elapsed_total: z.object({
-      human: z.string(),
-      nanos: z.number(),
-      secs: z.number(),
-    }),
-    stats: Stats,
-  }),
-})
-
-const Result = z.union([Begin, Match, End, Summary])
-
-export type Result = z.infer<typeof Result>
-export type Match = z.infer<typeof Match>
-export type Item = Match["data"]
-export type Begin = z.infer<typeof Begin>
-export type End = z.infer<typeof End>
-export type Summary = z.infer<typeof Summary>
-export type Row = Match["data"]
-
-export interface SearchResult {
-  items: Item[]
-  partial: boolean
-}
-
-export interface FilesInput {
-  cwd: string
-  glob?: string[]
-  hidden?: boolean
-  follow?: boolean
-  maxDepth?: number
-  signal?: AbortSignal
-}
-
-export interface SearchInput {
-  cwd: string
-  pattern: string
-  glob?: string[]
-  limit?: number
-  follow?: boolean
-  file?: string[]
-  signal?: AbortSignal
-}
-
-export interface TreeInput {
-  cwd: string
-  limit?: number
-  signal?: AbortSignal
-}
-
-export interface Interface {
-  readonly files: (input: FilesInput) => Stream.Stream<string, PlatformError | Error>
-  readonly tree: (input: TreeInput) => Effect.Effect<string, PlatformError | Error>
-  readonly search: (input: SearchInput) => Effect.Effect<SearchResult, PlatformError | Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Ripgrep") {}
-
-function env() {
-  const env = sanitizedProcessEnv()
-  delete env.RIPGREP_CONFIG_PATH
-  return env
-}
-
-function aborted(signal?: AbortSignal) {
-  const err = signal?.reason
-  if (err instanceof Error) return err
-  const out = new Error("Aborted")
-  out.name = "AbortError"
-  return out
-}
-
-function waitForAbort(signal?: AbortSignal) {
-  if (!signal) return Effect.never
-  if (signal.aborted) return Effect.fail(aborted(signal))
-  return Effect.callback<never, Error>((resume) => {
-    const onabort = () => resume(Effect.fail(aborted(signal)))
-    signal.addEventListener("abort", onabort, { once: true })
-    return Effect.sync(() => signal.removeEventListener("abort", onabort))
-  })
-}
-
-function error(stderr: string, code: number) {
-  const err = new Error(stderr.trim() || `ripgrep failed with code ${code}`)
-  err.name = "RipgrepError"
-  return err
-}
-
-function clean(file: string) {
-  return path.normalize(file.replace(/^\.[\\/]/, ""))
-}
-
-function row(data: Row): Row {
-  return {
-    ...data,
-    path: {
-      ...data.path,
-      text: clean(data.path.text),
-    },
-  }
-}
-
-function parse(line: string) {
-  return Effect.try({
-    try: () => Result.parse(JSON.parse(line)),
-    catch: (cause) => new Error("invalid ripgrep output", { cause }),
-  })
-}
-
-function fail(queue: Queue.Queue<string, PlatformError | Error | Cause.Done>, err: PlatformError | Error) {
-  Queue.failCauseUnsafe(queue, Cause.fail(err))
-}
-
-function filesArgs(input: FilesInput) {
-  const args = ["--no-config", "--files", "--glob=!.git/*"]
-  if (input.follow) args.push("--follow")
-  if (input.hidden !== false) args.push("--hidden")
-  if (input.hidden === false) args.push("--glob=!.*")
-  if (input.maxDepth !== undefined) args.push(`--max-depth=${input.maxDepth}`)
-  if (input.glob) {
-    for (const glob of input.glob) args.push(`--glob=${glob}`)
-  }
-  args.push(".")
-  return args
-}
-
-function searchArgs(input: SearchInput) {
-  const args = ["--no-config", "--json", "--hidden", "--glob=!.git/*", "--no-messages"]
-  if (input.follow) args.push("--follow")
-  if (input.glob) {
-    for (const glob of input.glob) args.push(`--glob=${glob}`)
-  }
-  if (input.limit) args.push(`--max-count=${input.limit}`)
-  args.push("--", input.pattern, ...(input.file ?? ["."]))
-  return args
-}
-
-function raceAbort<A, E, R>(effect: Effect.Effect<A, E, R>, signal?: AbortSignal) {
-  return signal ? effect.pipe(Effect.raceFirst(waitForAbort(signal))) : effect
-}
-
-export const layer: Layer.Layer<Service, never, AppFileSystem.Service | ChildProcessSpawner | HttpClient.HttpClient> =
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
-      const spawner = yield* ChildProcessSpawner
-
-      const run = Effect.fnUntraced(function* (command: string, args: string[], opts?: { cwd?: string }) {
-        const handle = yield* spawner.spawn(
-          ChildProcess.make(command, args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" }),
-        )
-        const [stdout, stderr, code] = yield* Effect.all(
-          [
-            Stream.mkString(Stream.decodeText(handle.stdout)),
-            Stream.mkString(Stream.decodeText(handle.stderr)),
-            handle.exitCode,
-          ],
-          { concurrency: "unbounded" },
-        )
-        return { stdout, stderr, code }
-      }, Effect.scoped)
-
-      const extract = Effect.fnUntraced(function* (
-        archive: string,
-        config: (typeof PLATFORM)[keyof typeof PLATFORM],
-        target: string,
-      ) {
-        const dir = yield* fs.makeTempDirectoryScoped({ directory: Global.Path.bin, prefix: "ripgrep-" })
-
-        if (config.extension === "zip") {
-          const shell = (yield* Effect.sync(() => which("powershell.exe") ?? which("pwsh.exe"))) ?? "powershell.exe"
-          const result = yield* run(shell, [
-            "-NoProfile",
-            "-NonInteractive",
-            "-Command",
-            `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -LiteralPath '${archive.replaceAll("'", "''")}' -DestinationPath '${dir.replaceAll("'", "''")}' -Force`,
-          ])
-          if (result.code !== 0) {
-            return yield* Effect.fail(error(result.stderr || result.stdout, result.code))
-          }
-        }
-
-        if (config.extension === "tar.gz") {
-          const result = yield* run("tar", ["-xzf", archive, "-C", dir])
-          if (result.code !== 0) {
-            return yield* Effect.fail(error(result.stderr || result.stdout, result.code))
-          }
-        }
-
-        const extracted = path.join(
-          dir,
-          `ripgrep-${VERSION}-${config.platform}`,
-          process.platform === "win32" ? "rg.exe" : "rg",
-        )
-        if (!(yield* fs.isFile(extracted))) {
-          return yield* Effect.fail(new Error(`ripgrep archive did not contain executable: ${extracted}`))
-        }
-
-        yield* fs.copyFile(extracted, target)
-        if (process.platform === "win32") return
-        yield* fs.chmod(target, 0o755)
-      }, Effect.scoped)
-
-      const filepath = yield* Effect.cached(
-        Effect.gen(function* () {
-          const system = yield* Effect.sync(() => which(process.platform === "win32" ? "rg.exe" : "rg"))
-          if (system && (yield* fs.isFile(system).pipe(Effect.orDie))) return system
-
-          const target = path.join(Global.Path.bin, `rg${process.platform === "win32" ? ".exe" : ""}`)
-          if (yield* fs.isFile(target).pipe(Effect.orDie)) return target
-
-          const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
-          const config = PLATFORM[platformKey]
-          if (!config) {
-            return yield* Effect.fail(new Error(`unsupported platform for ripgrep: ${platformKey}`))
-          }
-
-          const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`
-          const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`
-          const archive = path.join(Global.Path.bin, filename)
-
-          log.info("downloading ripgrep", { url })
-          yield* fs.ensureDir(Global.Path.bin).pipe(Effect.orDie)
-
-          const bytes = yield* HttpClientRequest.get(url).pipe(
-            http.execute,
-            Effect.flatMap((response) => response.arrayBuffer),
-            Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))),
-          )
-          if (bytes.byteLength === 0) {
-            return yield* Effect.fail(new Error(`failed to download ripgrep from ${url}`))
-          }
-
-          yield* fs.writeWithDirs(archive, new Uint8Array(bytes))
-          yield* extract(archive, config, target)
-          yield* fs.remove(archive, { force: true }).pipe(Effect.ignore)
-          return target
-        }),
-      )
-
-      const check = Effect.fnUntraced(function* (cwd: string) {
-        if (yield* fs.isDir(cwd).pipe(Effect.orDie)) return
-        return yield* Effect.fail(
-          Object.assign(new Error(`No such file or directory: '${cwd}'`), {
-            code: "ENOENT",
-            errno: -2,
-            path: cwd,
-          }),
-        )
-      })
-
-      const command = Effect.fnUntraced(function* (cwd: string, args: string[]) {
-        const binary = yield* filepath
-        return ChildProcess.make(binary, args, {
-          cwd,
-          env: env(),
-          extendEnv: true,
-          stdin: "ignore",
-        })
-      })
-
-      const files: Interface["files"] = (input) =>
-        Stream.callback<string, PlatformError | Error>((queue) =>
-          Effect.gen(function* () {
-            yield* Effect.forkScoped(
-              Effect.gen(function* () {
-                yield* check(input.cwd)
-                const handle = yield* spawner.spawn(yield* command(input.cwd, filesArgs(input)))
-                const stderr = yield* Stream.mkString(Stream.decodeText(handle.stderr)).pipe(Effect.forkScoped)
-                const stdout = yield* Stream.decodeText(handle.stdout).pipe(
-                  Stream.splitLines,
-                  Stream.filter((line) => line.length > 0),
-                  Stream.runForEach((line) => Effect.sync(() => Queue.offerUnsafe(queue, clean(line)))),
-                  Effect.forkScoped,
-                )
-                const code = yield* raceAbort(handle.exitCode, input.signal)
-                yield* Fiber.join(stdout)
-                if (code === 0 || code === 1) {
-                  Queue.endUnsafe(queue)
-                  return
-                }
-                fail(queue, error(yield* Fiber.join(stderr), code))
-              }).pipe(
-                Effect.catch((err) =>
-                  Effect.sync(() => {
-                    fail(queue, err)
-                  }),
-                ),
-              ),
-            )
-          }),
-        )
-
-      const search: Interface["search"] = Effect.fn("Ripgrep.search")(function* (input: SearchInput) {
-        yield* check(input.cwd)
-
-        const program = Effect.scoped(
-          Effect.gen(function* () {
-            const handle = yield* spawner.spawn(yield* command(input.cwd, searchArgs(input)))
-
-            const [items, stderr, code] = yield* Effect.all(
-              [
-                Stream.decodeText(handle.stdout).pipe(
-                  Stream.splitLines,
-                  Stream.filter((line) => line.length > 0),
-                  Stream.mapEffect(parse),
-                  Stream.filter((item): item is Match => item.type === "match"),
-                  Stream.map((item) => row(item.data)),
-                  Stream.runCollect,
-                  Effect.map((chunk) => [...chunk]),
-                ),
-                Stream.mkString(Stream.decodeText(handle.stderr)),
-                handle.exitCode,
-              ],
-              { concurrency: "unbounded" },
-            )
-
-            if (code !== 0 && code !== 1 && code !== 2) {
-              return yield* Effect.fail(error(stderr, code))
-            }
-
-            return {
-              items: code === 1 ? [] : items,
-              partial: code === 2,
-            }
-          }),
-        )
-
-        return yield* raceAbort(program, input.signal)
-      })
-
-      const tree: Interface["tree"] = Effect.fn("Ripgrep.tree")(function* (input: TreeInput) {
-        log.info("tree", input)
-        const list = Array.from(yield* files({ cwd: input.cwd, signal: input.signal }).pipe(Stream.runCollect))
-
-        interface Node {
-          name: string
-          children: Map<string, Node>
-        }
-
-        function child(node: Node, name: string) {
-          const item = node.children.get(name)
-          if (item) return item
-          const next = { name, children: new Map() }
-          node.children.set(name, next)
-          return next
-        }
-
-        function count(node: Node): number {
-          return Array.from(node.children.values()).reduce((sum, child) => sum + 1 + count(child), 0)
-        }
-
-        const root: Node = { name: "", children: new Map() }
-        for (const file of list) {
-          if (file.includes(".sleepycode")) continue
-          const parts = file.split(path.sep)
-          if (parts.length < 2) continue
-          let node = root
-          for (const part of parts.slice(0, -1)) {
-            node = child(node, part)
-          }
-        }
-
-        const total = count(root)
-        const limit = input.limit ?? total
-        const lines: string[] = []
-        const queue: Array<{ node: Node; path: string }> = Array.from(root.children.values())
-          .sort((a, b) => a.name.localeCompare(b.name))
-          .map((node) => ({ node, path: node.name }))
-
-        let used = 0
-        for (let i = 0; i < queue.length && used < limit; i++) {
-          const item = queue[i]
-          lines.push(item.path)
-          used++
-          queue.push(
-            ...Array.from(item.node.children.values())
-              .sort((a, b) => a.name.localeCompare(b.name))
-              .map((node) => ({ node, path: `${item.path}/${node.name}` })),
-          )
-        }
-
-        if (total > used) lines.push(`[${total - used} truncated]`)
-        return lines.join("\n")
-      })
-
-      return Service.of({ files, tree, search })
-    }),
-  )
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(CrossSpawnSpawner.defaultLayer),
-)
-
-export * as Ripgrep from "./ripgrep"

package/src/file/watcher.ts

@@ -1,163 +0,0 @@
-import { Cause, Effect, Layer, Context } from "effect"
-// @ts-ignore
-import { createWrapper } from "@parcel/watcher/wrapper"
-import type ParcelWatcher from "@parcel/watcher"
-import { readdir } from "fs/promises"
-import path from "path"
-import z from "zod"
-import { Bus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { InstanceState } from "@/effect"
-import { Flag } from "@/flag/flag"
-import { Git } from "@/git"
-import { Instance } from "@/project/instance"
-import { lazy } from "@/util/lazy"
-import { Config } from "../config"
-import { FileIgnore } from "./ignore"
-import { Protected } from "./protected"
-import { Log } from "../util"
-
-declare const OPENCODE_LIBC: string | undefined
-
-const log = Log.create({ service: "file.watcher" })
-const SUBSCRIBE_TIMEOUT_MS = 10_000
-
-export const Event = {
-  Updated: BusEvent.define(
-    "file.watcher.updated",
-    z.object({
-      file: z.string(),
-      event: z.union([z.literal("add"), z.literal("change"), z.literal("unlink")]),
-    }),
-  ),
-}
-
-const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
-  try {
-    const binding = require(
-      `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${OPENCODE_LIBC || "glibc"}` : ""}`,
-    )
-    return createWrapper(binding) as typeof import("@parcel/watcher")
-  } catch (error) {
-    log.error("failed to load watcher binding", { error })
-    return
-  }
-})
-
-function getBackend() {
-  if (process.platform === "win32") return "windows"
-  if (process.platform === "darwin") return "fs-events"
-  if (process.platform === "linux") return "inotify"
-}
-
-function protecteds(dir: string) {
-  return Protected.paths().filter((item) => {
-    const rel = path.relative(dir, item)
-    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
-  })
-}
-
-export const hasNativeBinding = () => !!watcher()
-
-export interface Interface {
-  readonly init: () => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/FileWatcher") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const git = yield* Git.Service
-
-    const state = yield* InstanceState.make(
-      Effect.fn("FileWatcher.state")(
-        function* () {
-          if (yield* Flag.SLEEPYCODE_EXPERIMENTAL_DISABLE_FILEWATCHER) return
-
-          log.info("init", { directory: Instance.directory })
-
-          const backend = getBackend()
-          if (!backend) {
-            log.error("watcher backend not supported", { directory: Instance.directory, platform: process.platform })
-            return
-          }
-
-          const w = watcher()
-          if (!w) return
-
-          log.info("watcher backend", { directory: Instance.directory, platform: process.platform, backend })
-
-          const subs: ParcelWatcher.AsyncSubscription[] = []
-          yield* Effect.addFinalizer(() =>
-            Effect.promise(() => Promise.allSettled(subs.map((sub) => sub.unsubscribe()))),
-          )
-
-          const cb: ParcelWatcher.SubscribeCallback = Instance.bind((err, evts) => {
-            if (err) return
-            for (const evt of evts) {
-              if (evt.type === "create") void Bus.publish(Event.Updated, { file: evt.path, event: "add" })
-              if (evt.type === "update") void Bus.publish(Event.Updated, { file: evt.path, event: "change" })
-              if (evt.type === "delete") void Bus.publish(Event.Updated, { file: evt.path, event: "unlink" })
-            }
-          })
-
-          const subscribe = (dir: string, ignore: string[]) => {
-            const pending = w.subscribe(dir, cb, { ignore, backend })
-            return Effect.gen(function* () {
-              const sub = yield* Effect.promise(() => pending)
-              subs.push(sub)
-            }).pipe(
-              Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
-              Effect.catchCause((cause) => {
-                log.error("failed to subscribe", { dir, cause: Cause.pretty(cause) })
-                pending.then((s) => s.unsubscribe()).catch(() => {})
-                return Effect.void
-              }),
-            )
-          }
-
-          const cfg = yield* config.get()
-          const cfgIgnores = cfg.watcher?.ignore ?? []
-
-          if (yield* Flag.SLEEPYCODE_EXPERIMENTAL_FILEWATCHER) {
-            yield* subscribe(Instance.directory, [
-              ...FileIgnore.PATTERNS,
-              ...cfgIgnores,
-              ...protecteds(Instance.directory),
-            ])
-          }
-
-          if (Instance.project.vcs === "git") {
-            const result = yield* git.run(["rev-parse", "--git-dir"], {
-              cwd: Instance.project.worktree,
-            })
-            const vcsDir =
-              result.exitCode === 0 ? path.resolve(Instance.project.worktree, result.text().trim()) : undefined
-            if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
-              const ignore = (yield* Effect.promise(() => readdir(vcsDir).catch(() => []))).filter(
-                (entry) => entry !== "HEAD",
-              )
-              yield* subscribe(vcsDir, ignore)
-            }
-          }
-        },
-        Effect.catchCause((cause) => {
-          log.error("failed to init watcher service", { cause: Cause.pretty(cause) })
-          return Effect.void
-        }),
-      ),
-    )
-
-    return Service.of({
-      init: Effect.fn("FileWatcher.init")(function* () {
-        yield* InstanceState.get(state)
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Git.defaultLayer))
-
-export * as FileWatcher from "./watcher"