saeeol 1.4.1 → 1.4.3

package/src/effect/runner.ts

@@ -1,222 +0,0 @@
-import { Cause, Deferred, Effect, Exit, Fiber, Latch, Schema, Scope, SynchronizedRef } from "effect"
-
-export interface Runner<A, E = never> {
-  readonly state: State<A, E>
-  readonly busy: boolean
-  readonly ensureRunning: (work: Effect.Effect<A, E>) => Effect.Effect<A, E>
-  readonly startShell: (work: Effect.Effect<A, E>, ready?: Latch.Latch) => Effect.Effect<A, E>
-  readonly cancel: Effect.Effect<void>
-}
-
-export class Cancelled extends Schema.TaggedErrorClass<Cancelled>()("RunnerCancelled", {}) {}
-
-interface RunHandle<A, E> {
-  id: number
-  done: Deferred.Deferred<A, E | Cancelled>
-  fiber: Fiber.Fiber<A, E>
-}
-
-interface ShellHandle<A, E> {
-  id: number
-  cancelled: Deferred.Deferred<void>
-  ready?: Latch.Latch
-  fiber: Fiber.Fiber<A, E>
-}
-
-interface PendingHandle<A, E> {
-  id: number
-  done: Deferred.Deferred<A, E | Cancelled>
-  work: Effect.Effect<A, E>
-}
-
-export type State<A, E> =
-  | { readonly _tag: "Idle" }
-  | { readonly _tag: "Running"; readonly run: RunHandle<A, E> }
-  | { readonly _tag: "Shell"; readonly shell: ShellHandle<A, E> }
-  | { readonly _tag: "ShellThenRun"; readonly shell: ShellHandle<A, E>; readonly run: PendingHandle<A, E> }
-
-export const make = <A, E = never>(
-  scope: Scope.Scope,
-  opts?: {
-    onIdle?: Effect.Effect<void>
-    onBusy?: Effect.Effect<void>
-    onInterrupt?: Effect.Effect<A, E>
-    busy?: () => never
-  },
-): Runner<A, E> => {
-  const ref = SynchronizedRef.makeUnsafe<State<A, E>>({ _tag: "Idle" })
-  const idle = opts?.onIdle ?? Effect.void
-  const busy = opts?.onBusy ?? Effect.void
-  const onInterrupt = opts?.onInterrupt
-  let ids = 0
-
-  const state = () => SynchronizedRef.getUnsafe(ref)
-  const next = () => {
-    ids += 1
-    return ids
-  }
-
-  const complete = (done: Deferred.Deferred<A, E | Cancelled>, exit: Exit.Exit<A, E>) =>
-    Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)
-      ? Deferred.fail(done, new Cancelled()).pipe(Effect.asVoid)
-      : Deferred.done(done, exit).pipe(Effect.asVoid)
-
-  const awaitDone = (done: Deferred.Deferred<A, E | Cancelled>) =>
-    Deferred.await(done).pipe(Effect.catchTag("RunnerCancelled", (e) => onInterrupt ?? Effect.die(e)))
-
-  const idleIfCurrent = () =>
-    SynchronizedRef.modify(ref, (st) => [st._tag === "Idle" ? idle : Effect.void, st] as const).pipe(Effect.flatten)
-
-  const finishRun = (id: number, done: Deferred.Deferred<A, E | Cancelled>, exit: Exit.Exit<A, E>) =>
-    SynchronizedRef.modify(
-      ref,
-      (st) =>
-        [
-          Effect.gen(function* () {
-            if (st._tag === "Running" && st.run.id === id) yield* idle
-            yield* complete(done, exit)
-          }),
-          st._tag === "Running" && st.run.id === id ? ({ _tag: "Idle" } as const) : st,
-        ] as const,
-    ).pipe(Effect.flatten)
-
-  const startRun = (work: Effect.Effect<A, E>, done: Deferred.Deferred<A, E | Cancelled>) =>
-    Effect.gen(function* () {
-      const id = next()
-      const fiber = yield* work.pipe(
-        Effect.onExit((exit) => finishRun(id, done, exit)),
-        Effect.forkIn(scope),
-      )
-      return { id, done, fiber } satisfies RunHandle<A, E>
-    })
-
-  const finishShell = (id: number) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        if (st._tag === "Shell" && st.shell.id === id) {
-          return [idle, { _tag: "Idle" }] as const
-        }
-        if (st._tag === "ShellThenRun" && st.shell.id === id) {
-          const run = yield* startRun(st.run.work, st.run.done)
-          return [Effect.void, { _tag: "Running", run }] as const
-        }
-        return [Effect.void, st] as const
-      }),
-    ).pipe(Effect.flatten)
-
-  const stopShell = (shell: ShellHandle<A, E>) =>
-    Effect.gen(function* () {
-      if (shell.ready) yield* shell.ready.await.pipe(Effect.exit, Effect.asVoid)
-      yield* Deferred.succeed(shell.cancelled, undefined).pipe(Effect.asVoid)
-      yield* Fiber.interrupt(shell.fiber)
-    })
-
-  const ensureRunning = (work: Effect.Effect<A, E>) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        switch (st._tag) {
-          case "Running":
-          case "ShellThenRun":
-            return [awaitDone(st.run.done), st] as const
-          case "Shell": {
-            const run = {
-              id: next(),
-              done: yield* Deferred.make<A, E | Cancelled>(),
-              work,
-            } satisfies PendingHandle<A, E>
-            return [awaitDone(run.done), { _tag: "ShellThenRun", shell: st.shell, run }] as const
-          }
-          case "Idle": {
-            const done = yield* Deferred.make<A, E | Cancelled>()
-            const run = yield* startRun(work, done)
-            return [awaitDone(done), { _tag: "Running", run }] as const
-          }
-        }
-      }),
-    ).pipe(Effect.flatten)
-
-  const startShell = (work: Effect.Effect<A, E>, ready?: Latch.Latch) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        if (st._tag !== "Idle") {
-          return [
-            Effect.sync(() => {
-              if (opts?.busy) opts.busy()
-              throw new Error("Runner is busy")
-            }),
-            st,
-          ] as const
-        }
-        yield* busy
-        const id = next()
-        const cancelled = yield* Deferred.make<void>()
-        const fiber = yield* work.pipe(Effect.ensuring(finishShell(id)), Effect.forkChild)
-        const shell = { id, cancelled, ready, fiber } satisfies ShellHandle<A, E>
-        return [
-          Effect.gen(function* () {
-            const exit = yield* Fiber.await(fiber)
-            if (Exit.isSuccess(exit)) return exit.value
-            if (
-              Cause.hasInterruptsOnly(exit.cause) ||
-              ((yield* Deferred.isDone(cancelled)) && Cause.hasInterrupts(exit.cause) && !Cause.hasDies(exit.cause))
-            ) {
-              if (onInterrupt) return yield* onInterrupt
-              return yield* Effect.die(new Cancelled())
-            }
-            return yield* Effect.failCause(exit.cause)
-          }),
-          { _tag: "Shell", shell },
-        ] as const
-      }),
-    ).pipe(Effect.flatten)
-
-  const cancel = SynchronizedRef.modify(ref, (st) => {
-    switch (st._tag) {
-      case "Idle":
-        return [Effect.void, st] as const
-      case "Running":
-        return [
-          Effect.gen(function* () {
-            yield* Fiber.interrupt(st.run.fiber)
-            yield* Deferred.await(st.run.done).pipe(Effect.exit, Effect.asVoid)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-      case "Shell":
-        return [
-          Effect.gen(function* () {
-            yield* stopShell(st.shell)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-      case "ShellThenRun":
-        return [
-          Effect.gen(function* () {
-            yield* stopShell(st.shell)
-            yield* Deferred.fail(st.run.done, new Cancelled()).pipe(Effect.asVoid)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-    }
-  }).pipe(Effect.flatten)
-
-  return {
-    get state() {
-      return state()
-    },
-    get busy() {
-      return state()._tag !== "Idle"
-    },
-    ensureRunning,
-    startShell,
-    cancel,
-  }
-}
-
-export * as Runner from "./runner"

package/src/effect/service-use.ts

@@ -1,38 +0,0 @@
-import { Context, Effect } from "effect"
-
-type EffectMethod = (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-
-type ServiceUse<Identifier, Shape> = {
-  readonly [Key in keyof Shape as Shape[Key] extends EffectMethod ? Key : never]: Shape[Key] extends (
-    ...args: infer Args
-  ) => infer Return
-    ? Args extends ReadonlyArray<unknown>
-      ? Return extends Effect.Effect<infer A, infer E, infer R>
-        ? (...args: Args) => Effect.Effect<A, E, R | Identifier>
-        : never
-      : never
-    : never
-}
-
-export const serviceUse = <Identifier, Shape>(tag: Context.Service<Identifier, Shape>) => {
-  // This is the only dynamic boundary: TypeScript knows the accessor shape,
-  // but Proxy property names are runtime values.
-  const access = new Proxy(
-    {},
-    {
-      get: (_, key) => {
-        if (typeof key !== "string") return undefined
-        return (...args: unknown[]) =>
-          tag.use((service) => {
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy keys are checked at runtime.
-            const method = service[key as keyof Shape]
-            if (typeof method !== "function") return Effect.die(new Error(`Service method not found: ${key}`))
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- ServiceUse exposes only Effect-returning methods.
-            return (method as (...args: unknown[]) => Effect.Effect<unknown, unknown, unknown>)(...args)
-          })
-      },
-    },
-  )
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy implements the mapped accessor surface lazily.
-  return access as ServiceUse<Identifier, Shape>
-}

package/src/env/index.ts

@@ -1,37 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-
-type State = Record<string, string | undefined>
-
-export interface Interface {
-  readonly get: (key: string) => Effect.Effect<string | undefined>
-  readonly all: () => Effect.Effect<State>
-  readonly set: (key: string, value: string) => Effect.Effect<void>
-  readonly remove: (key: string) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Env") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const state = yield* InstanceState.make<State>(Effect.fn("Env.state")(() => Effect.succeed({ ...process.env })))
-
-    const get = Effect.fn("Env.get")((key: string) => InstanceState.use(state, (env) => env[key]))
-    const all = Effect.fn("Env.all")(() => InstanceState.get(state))
-    const set = Effect.fn("Env.set")(function* (key: string, value: string) {
-      const env = yield* InstanceState.get(state)
-      env[key] = value
-    })
-    const remove = Effect.fn("Env.remove")(function* (key: string) {
-      const env = yield* InstanceState.get(state)
-      delete env[key]
-    })
-
-    return Service.of({ get, all, set, remove })
-  }),
-)
-
-export const defaultLayer = layer
-
-export * as Env from "."

package/src/file/file-search.ts

@@ -1,60 +0,0 @@
-import { Effect } from "effect"
-import fuzzysort from "fuzzysort"
-import type { Entry } from "./file-status"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "file" })
-
-const hidden = (item: string) => {
-  const normalized = item.replaceAll("\\", "/").replace(/\/+$/, "")
-  return normalized.split("/").some((part) => part.startsWith(".") && part.length > 1)
-}
-
-const sortHiddenLast = (items: string[], prefer: boolean) => {
-  if (prefer) return items
-  const visible: string[] = []
-  const hiddenItems: string[] = []
-  for (const item of items) {
-    if (hidden(item)) hiddenItems.push(item)
-    else visible.push(item)
-  }
-  return [...visible, ...hiddenItems]
-}
-
-export function makeSearchOp(deps: {
-  ensure: () => Effect.Effect<void>
-  getCache: () => Effect.Effect<{ cache: Entry }>
-}) {
-  const search = Effect.fn("File.search")(function* (input: {
-    query: string
-    limit?: number
-    dirs?: boolean
-    type?: "file" | "directory"
-  }) {
-    yield* deps.ensure()
-    const { cache } = yield* deps.getCache()
-
-    const query = input.query.trim()
-    const limit = input.limit ?? 100
-    const kind = input.type ?? (input.dirs === false ? "file" : "all")
-    log.info("search", { query, kind })
-
-    const preferHidden = query.startsWith(".") || query.includes("/.")
-
-    if (!query) {
-      if (kind === "file") return cache.files.slice(0, limit)
-      return sortHiddenLast(cache.dirs.toSorted(), preferHidden).slice(0, limit)
-    }
-
-    const items = kind === "file" ? cache.files : kind === "directory" ? cache.dirs : [...cache.files, ...cache.dirs]
-
-    const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit
-    const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((item) => item.target)
-    const output = kind === "directory" ? sortHiddenLast(sorted, preferHidden).slice(0, limit) : sorted
-
-    log.info("search", { query, kind, results: output.length })
-    return output
-  })
-
-  return { search }
-}

package/src/file/file-status.ts

@@ -1,174 +0,0 @@
-import { InstanceState } from "@/effect/instance-state"
-import { Git } from "@/git"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Effect, Schema } from "effect"
-import path from "path"
-import * as Log from "@saeeol/core/util/log"
-import { NonNegativeInt, type DeepMutable, withStatics } from "@/util/schema"
-import { zod } from "@/util/effect-zod"
-
-const log = Log.create({ service: "file" })
-
-export const Info = Schema.Struct({
-  path: Schema.String,
-  added: NonNegativeInt,
-  removed: NonNegativeInt,
-  status: Schema.Literals(["added", "deleted", "modified"]),
-})
-  .annotate({ identifier: "File" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = DeepMutable<Schema.Schema.Type<typeof Info>>
-
-export type Entry = { files: string[]; dirs: string[] }
-
-const binary = new Set([
-  "exe", "dll", "pdb", "bin", "so", "dylib", "o", "a", "lib",
-  "wav", "mp3", "ogg", "oga", "ogv", "ogx", "flac", "aac", "wma", "m4a", "weba",
-  "mp4", "avi", "mov", "wmv", "flv", "webm", "mkv",
-  "zip", "tar", "gz", "gzip", "bz", "bz2", "bzip", "bzip2", "7z", "rar", "xz", "lz", "z",
-  "pdf", "doc", "docx", "ppt", "pptx", "xls", "xlsx",
-  "dmg", "iso", "img", "vmdk",
-  "ttf", "otf", "woff", "woff2", "eot",
-  "sqlite", "db", "mdb",
-  "apk", "ipa", "aab", "xapk", "app", "pkg", "deb", "rpm", "snap", "flatpak", "appimage",
-  "msi", "msp",
-  "jar", "war", "ear", "class", "kotlin_module", "dex", "vdex", "odex", "oat", "art",
-  "wasm", "wat", "bc", "ll", "s",
-  "ko", "sys", "drv", "efi", "rom", "com",
-])
-
-const image = new Set([
-  "png", "jpg", "jpeg", "gif", "bmp", "webp", "ico", "tif", "tiff", "svg", "svgz",
-  "avif", "apng", "jxl", "heic", "heif", "raw", "cr2", "nef", "arw", "dng", "orf", "raf", "pef", "x3f",
-])
-
-const text = new Set([
-  "ts", "tsx", "mts", "cts", "mtsx", "ctsx", "js", "jsx", "mjs", "cjs",
-  "sh", "bash", "zsh", "fish", "ps1", "psm1", "cmd", "bat",
-  "json", "jsonc", "json5", "yaml", "yml", "toml", "md", "mdx", "txt", "xml",
-  "html", "htm", "css", "scss", "sass", "less", "graphql", "gql", "sql",
-  "ini", "cfg", "conf", "env",
-])
-
-const textName = new Set([
-  "dockerfile", "makefile", ".gitignore", ".gitattributes",
-  ".editorconfig", ".npmrc", ".nvmrc", ".prettierrc", ".eslintrc",
-])
-
-const mime: Record<string, string> = {
-  png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif",
-  bmp: "image/bmp", webp: "image/webp", ico: "image/x-icon", tif: "image/tiff",
-  tiff: "image/tiff", svg: "image/svg+xml", svgz: "image/svg+xml", avif: "image/avif",
-  apng: "image/apng", jxl: "image/jxl", heic: "image/heic", heif: "image/heif",
-}
-
-const ext = (file: string) => path.extname(file).toLowerCase().slice(1)
-const name = (file: string) => path.basename(file).toLowerCase()
-export const isImageByExtension = (file: string) => image.has(ext(file))
-export const isTextByExtension = (file: string) => text.has(ext(file))
-export const isTextByName = (file: string) => textName.has(name(file))
-export const isBinaryByExtension = (file: string) => binary.has(ext(file))
-export const isImage = (mimeType: string) => mimeType.startsWith("image/")
-export const getImageMimeType = (file: string) => mime[ext(file)] || "image/" + ext(file)
-
-export function shouldEncode(mimeType: string) {
-  const type = mimeType.toLowerCase()
-  log.debug("shouldEncode", { type })
-  if (!type) return false
-  if (type.startsWith("text/")) return false
-  if (type.includes("charset=")) return false
-  const top = type.split("/", 2)[0]
-  return ["image", "audio", "video", "font", "model", "multipart"].includes(top)
-}
-
-export function makeStatusOps(git: any, appFs: any) {
-  const gitText = Effect.fnUntraced(function* (args: string[]) {
-    return (yield* git.run(args, { cwd: (yield* InstanceState.context).directory })).text()
-  })
-
-  const status = Effect.fn("File.status")(function* () {
-    const ctx = yield* InstanceState.context
-    if (ctx.project.vcs !== "git") return []
-
-    const diffOutput = yield* gitText([
-      "-c",
-      "core.fsmonitor=false",
-      "-c",
-      "core.quotepath=false",
-      "diff",
-      "--numstat",
-      "HEAD",
-    ])
-
-    const changed: Info[] = []
-
-    if (diffOutput.trim()) {
-      for (const line of diffOutput.trim().split("\n")) {
-        const [added, removed, file] = line.split("\t")
-        changed.push({
-          path: file,
-          added: added === "-" ? 0 : parseInt(added, 10),
-          removed: removed === "-" ? 0 : parseInt(removed, 10),
-          status: "modified",
-        })
-      }
-    }
-
-    const untrackedOutput = yield* gitText([
-      "-c",
-      "core.fsmonitor=false",
-      "-c",
-      "core.quotepath=false",
-      "ls-files",
-      "--others",
-      "--exclude-standard",
-    ])
-
-    if (untrackedOutput.trim()) {
-      for (const file of untrackedOutput.trim().split("\n")) {
-        const content = yield* appFs
-          .readFileString(path.join(ctx.directory, file))
-          .pipe(Effect.catch(() => Effect.succeed<string | undefined>(undefined)))
-        if (content === undefined) continue
-        changed.push({
-          path: file,
-          added: content.split("\n").length,
-          removed: 0,
-          status: "added",
-        })
-      }
-    }
-
-    const deletedOutput = yield* gitText([
-      "-c",
-      "core.fsmonitor=false",
-      "-c",
-      "core.quotepath=false",
-      "diff",
-      "--name-only",
-      "--diff-filter=D",
-      "HEAD",
-    ])
-
-    if (deletedOutput.trim()) {
-      for (const file of deletedOutput.trim().split("\n")) {
-        changed.push({
-          path: file,
-          added: 0,
-          removed: 0,
-          status: "deleted",
-        })
-      }
-    }
-
-    return changed.map((item) => {
-      const full = path.isAbsolute(item.path) ? item.path : path.join(ctx.directory, item.path)
-      return {
-        ...item,
-        path: path.relative(ctx.directory, full),
-      }
-    })
-  })
-
-  return { gitText, status }
-}

package/src/file/ignore.ts

@@ -1,81 +0,0 @@
-import { Glob } from "@saeeol/core/util/glob"
-
-const FOLDERS = new Set([
-  "node_modules",
-  "bower_components",
-  ".pnpm-store",
-  "vendor",
-  ".npm",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  "target",
-  "bin",
-  "obj",
-  ".git",
-  ".svn",
-  ".hg",
-  ".vscode",
-  ".idea",
-  ".turbo",
-  ".output",
-  "desktop",
-  ".sst",
-  ".cache",
-  ".webkit-cache",
-  "__pycache__",
-  ".pytest_cache",
-  "mypy_cache",
-  ".history",
-  ".gradle",
-])
-
-const FILES = [
-  "**/*.swp",
-  "**/*.swo",
-
-  "**/*.pyc",
-
-  // OS
-  "**/.DS_Store",
-  "**/Thumbs.db",
-
-  // Logs & temp
-  "**/logs/**",
-  "**/tmp/**",
-  "**/temp/**",
-  "**/*.log",
-
-  // Coverage/test outputs
-  "**/coverage/**",
-  "**/.nyc_output/**",
-]
-
-export const PATTERNS = [...FILES, ...FOLDERS]
-
-export function match(
-  filepath: string,
-  opts?: {
-    extra?: string[]
-    whitelist?: string[]
-  },
-) {
-  for (const pattern of opts?.whitelist || []) {
-    if (Glob.match(pattern, filepath)) return false
-  }
-
-  const parts = filepath.split(/[/\\]/)
-  for (let i = 0; i < parts.length; i++) {
-    if (FOLDERS.has(parts[i])) return true
-  }
-
-  const extra = opts?.extra || []
-  for (const pattern of [...FILES, ...extra]) {
-    if (Glob.match(pattern, filepath)) return true
-  }
-
-  return false
-}
-
-export * as FileIgnore from "./ignore"