saeeol 1.2.0 → 1.2.2

package/src/tool/edit-replacers.ts

@@ -1,288 +1 @@
-import { levenshtein, SINGLE_CANDIDATE_SIMILARITY_THRESHOLD, MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD } from "./edit-utils"
-
-export type Replacer = (content: string, find: string) => Generator<string, void, unknown>
-
-export const SimpleReplacer: Replacer = function* (_content, find) {
-  yield find
-}
-
-export const LineTrimmedReplacer: Replacer = function* (content, find) {
-  const originalLines = content.split("\n")
-  const searchLines = find.split("\n")
-  if (searchLines[searchLines.length - 1] === "") {
-    searchLines.pop()
-  }
-  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
-    let matches = true
-    for (let j = 0; j < searchLines.length; j++) {
-      const originalTrimmed = originalLines[i + j].trim()
-      const searchTrimmed = searchLines[j].trim()
-      if (originalTrimmed !== searchTrimmed) {
-        matches = false
-        break
-      }
-    }
-    if (matches) {
-      let matchStartIndex = 0
-      for (let k = 0; k < i; k++) {
-        matchStartIndex += originalLines[k].length + 1
-      }
-      let matchEndIndex = matchStartIndex
-      for (let k = 0; k < searchLines.length; k++) {
-        matchEndIndex += originalLines[i + k].length
-        if (k < searchLines.length - 1) {
-          matchEndIndex += 1
-        }
-      }
-      yield content.substring(matchStartIndex, matchEndIndex)
-    }
-  }
-}
-
-export const BlockAnchorReplacer: Replacer = function* (content, find) {
-  const originalLines = content.split("\n")
-  const searchLines = find.split("\n")
-  if (searchLines.length < 3) return
-  if (searchLines[searchLines.length - 1] === "") {
-    searchLines.pop()
-  }
-  const firstLineSearch = searchLines[0].trim()
-  const lastLineSearch = searchLines[searchLines.length - 1].trim()
-  const searchBlockSize = searchLines.length
-  const candidates: Array<{ startLine: number; endLine: number }> = []
-  for (let i = 0; i < originalLines.length; i++) {
-    if (originalLines[i].trim() !== firstLineSearch) continue
-    for (let j = i + 2; j < originalLines.length; j++) {
-      if (originalLines[j].trim() === lastLineSearch) {
-        candidates.push({ startLine: i, endLine: j })
-        break
-      }
-    }
-  }
-  if (candidates.length === 0) return
-  if (candidates.length === 1) {
-    const { startLine, endLine } = candidates[0]
-    const actualBlockSize = endLine - startLine + 1
-    let similarity = 0
-    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2)
-    if (linesToCheck > 0) {
-      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
-        const originalLine = originalLines[startLine + j].trim()
-        const searchLine = searchLines[j].trim()
-        const maxLen = Math.max(originalLine.length, searchLine.length)
-        if (maxLen === 0) continue
-        const distance = levenshtein(originalLine, searchLine)
-        similarity += (1 - distance / maxLen) / linesToCheck
-        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) break
-      }
-    } else {
-      similarity = 1.0
-    }
-    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
-      let matchStartIndex = 0
-      for (let k = 0; k < startLine; k++) {
-        matchStartIndex += originalLines[k].length + 1
-      }
-      let matchEndIndex = matchStartIndex
-      for (let k = startLine; k <= endLine; k++) {
-        matchEndIndex += originalLines[k].length
-        if (k < endLine) matchEndIndex += 1
-      }
-      yield content.substring(matchStartIndex, matchEndIndex)
-    }
-    return
-  }
-  let bestMatch: { startLine: number; endLine: number } | null = null
-  let maxSimilarity = -1
-  for (const candidate of candidates) {
-    const { startLine, endLine } = candidate
-    const actualBlockSize = endLine - startLine + 1
-    let similarity = 0
-    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2)
-    if (linesToCheck > 0) {
-      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
-        const originalLine = originalLines[startLine + j].trim()
-        const searchLine = searchLines[j].trim()
-        const maxLen = Math.max(originalLine.length, searchLine.length)
-        if (maxLen === 0) continue
-        const distance = levenshtein(originalLine, searchLine)
-        similarity += 1 - distance / maxLen
-      }
-      similarity /= linesToCheck
-    } else {
-      similarity = 1.0
-    }
-    if (similarity > maxSimilarity) {
-      maxSimilarity = similarity
-      bestMatch = candidate
-    }
-  }
-  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
-    const { startLine, endLine } = bestMatch
-    let matchStartIndex = 0
-    for (let k = 0; k < startLine; k++) {
-      matchStartIndex += originalLines[k].length + 1
-    }
-    let matchEndIndex = matchStartIndex
-    for (let k = startLine; k <= endLine; k++) {
-      matchEndIndex += originalLines[k].length
-      if (k < endLine) matchEndIndex += 1
-    }
-    yield content.substring(matchStartIndex, matchEndIndex)
-  }
-}
-
-export const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
-  const normalizeWhitespace = (text: string) => text.replace(/\s+/g, " ").trim()
-  const normalizedFind = normalizeWhitespace(find)
-  const lines = content.split("\n")
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    if (normalizeWhitespace(line) === normalizedFind) {
-      yield line
-    } else {
-      const normalizedLine = normalizeWhitespace(line)
-      if (normalizedLine.includes(normalizedFind)) {
-        const words = find.trim().split(/\s+/)
-        if (words.length > 0) {
-          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+")
-          try {
-            const regex = new RegExp(pattern)
-            const match = line.match(regex)
-            if (match) yield match[0]
-          } catch {
-            // Invalid regex pattern, skip
-          }
-        }
-      }
-    }
-  }
-  const findLines = find.split("\n")
-  if (findLines.length > 1) {
-    for (let i = 0; i <= lines.length - findLines.length; i++) {
-      const block = lines.slice(i, i + findLines.length)
-      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
-        yield block.join("\n")
-      }
-    }
-  }
-}
-
-export const IndentationFlexibleReplacer: Replacer = function* (content, find) {
-  const removeIndentation = (text: string) => {
-    const lines = text.split("\n")
-    const nonEmptyLines = lines.filter((line) => line.trim().length > 0)
-    if (nonEmptyLines.length === 0) return text
-    const minIndent = Math.min(
-      ...nonEmptyLines.map((line) => {
-        const match = line.match(/^(\s*)/)
-        return match ? match[1].length : 0
-      }),
-    )
-    return lines.map((line) => (line.trim().length === 0 ? line : line.slice(minIndent))).join("\n")
-  }
-  const normalizedFind = removeIndentation(find)
-  const contentLines = content.split("\n")
-  const findLines = find.split("\n")
-  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
-    const block = contentLines.slice(i, i + findLines.length).join("\n")
-    if (removeIndentation(block) === normalizedFind) {
-      yield block
-    }
-  }
-}
-
-export const EscapeNormalizedReplacer: Replacer = function* (content, find) {
-  const unescapeString = (str: string): string => {
-    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (_match, capturedChar: string) => {
-      switch (capturedChar) {
-        case "n": return "\n"
-        case "t": return "\t"
-        case "r": return "\r"
-        case "'": return "'"
-        case '"': return '"'
-        case "`": return "`"
-        case "\\": return "\\"
-        case "\n": return "\n"
-        case "$": return "$"
-        default: return capturedChar
-      }
-    })
-  }
-  const unescapedFind = unescapeString(find)
-  if (content.includes(unescapedFind)) {
-    yield unescapedFind
-  }
-  const lines = content.split("\n")
-  const findLines = unescapedFind.split("\n")
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n")
-    const unescapedBlock = unescapeString(block)
-    if (unescapedBlock === unescapedFind) {
-      yield block
-    }
-  }
-}
-
-export const MultiOccurrenceReplacer: Replacer = function* (content, find) {
-  let startIndex = 0
-  while (true) {
-    const index = content.indexOf(find, startIndex)
-    if (index === -1) break
-    yield find
-    startIndex = index + find.length
-  }
-}
-
-export const TrimmedBoundaryReplacer: Replacer = function* (content, find) {
-  const trimmedFind = find.trim()
-  if (trimmedFind === find) return
-  if (content.includes(trimmedFind)) {
-    yield trimmedFind
-  }
-  const lines = content.split("\n")
-  const findLines = find.split("\n")
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n")
-    if (block.trim() === trimmedFind) {
-      yield block
-    }
-  }
-}
-
-export const ContextAwareReplacer: Replacer = function* (content, find) {
-  const findLines = find.split("\n")
-  if (findLines.length < 3) return
-  if (findLines[findLines.length - 1] === "") {
-    findLines.pop()
-  }
-  const contentLines = content.split("\n")
-  const firstLine = findLines[0].trim()
-  const lastLine = findLines[findLines.length - 1].trim()
-  for (let i = 0; i < contentLines.length; i++) {
-    if (contentLines[i].trim() !== firstLine) continue
-    for (let j = i + 2; j < contentLines.length; j++) {
-      if (contentLines[j].trim() === lastLine) {
-        const blockLines = contentLines.slice(i, j + 1)
-        const block = blockLines.join("\n")
-        if (blockLines.length === findLines.length) {
-          let matchingLines = 0
-          let totalNonEmptyLines = 0
-          for (let k = 1; k < blockLines.length - 1; k++) {
-            const blockLine = blockLines[k].trim()
-            const findLine = findLines[k].trim()
-            if (blockLine.length > 0 || findLine.length > 0) {
-              totalNonEmptyLines++
-              if (blockLine === findLine) matchingLines++
-            }
-          }
-          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
-            yield block
-            break
-          }
-        }
-        break
-      }
-    }
-  }
-}
+export * from "./file/edit-replacers"

package/src/tool/edit-utils.ts

@@ -1,86 +1 @@
-import { createTwoFilesPatch, diffLines } from "diff"
-import { Snapshot } from "@/snapshot"
-
-export const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
-export const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3
-
-export function levenshtein(a: string, b: string): number {
-  if (a === "" || b === "") {
-    return Math.max(a.length, b.length)
-  }
-  const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
-    Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
-  )
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1
-      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
-    }
-  }
-  return matrix[a.length][b.length]
-}
-
-const MAX_DIFF_CONTENT = 500_000
-export function buildFileDiff(file: string, before: string, after: string): Snapshot.FileDiff {
-  const tooLarge = before.length > MAX_DIFF_CONTENT || after.length > MAX_DIFF_CONTENT
-  let additions = 0
-  let deletions = 0
-  if (!tooLarge) {
-    for (const change of diffLines(before, after)) {
-      if (change.added) additions += change.count || 0
-      if (change.removed) deletions += change.count || 0
-    }
-  }
-  return {
-    file,
-    patch: tooLarge ? "" : createTwoFilesPatch(file, file, before, after),
-    additions,
-    deletions,
-  }
-}
-
-export function normalizeLineEndings(text: string): string {
-  return text.replaceAll("\r\n", "\n")
-}
-
-export function detectLineEnding(text: string): "\n" | "\r\n" {
-  return text.includes("\r\n") ? "\r\n" : "\n"
-}
-
-export function convertToLineEnding(text: string, ending: "\n" | "\r\n"): string {
-  if (ending === "\n") return text
-  return text.replaceAll("\n", "\r\n")
-}
-
-export function trimDiff(diff: string): string {
-  const lines = diff.split("\n")
-  const contentLines = lines.filter(
-    (line) =>
-      (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) &&
-      !line.startsWith("---") &&
-      !line.startsWith("+++"),
-  )
-  if (contentLines.length === 0) return diff
-  let min = Infinity
-  for (const line of contentLines) {
-    const content = line.slice(1)
-    if (content.trim().length > 0) {
-      const match = content.match(/^(\s*)/)
-      if (match) min = Math.min(min, match[1].length)
-    }
-  }
-  if (min === Infinity || min === 0) return diff
-  const trimmedLines = lines.map((line) => {
-    if (
-      (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) &&
-      !line.startsWith("---") &&
-      !line.startsWith("+++")
-    ) {
-      const prefix = line[0]
-      const content = line.slice(1)
-      return prefix + content.slice(min)
-    }
-    return line
-  })
-  return trimmedLines.join("\n")
-}
+export * from "./file/edit-utils"

package/src/tool/edit.ts

@@ -1,262 +1 @@
-// the approaches in this edit tool are sourced from
-// https://github.com/cline/cline/blob/main/evals/diff-edits/diff-apply/diff-06-23-25.ts
-// https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/utils/editCorrector.ts
-// https://github.com/cline/cline/blob/main/evals/diff-edits/diff-apply/diff-06-26-25.ts
-
-import * as path from "path"
-import { Effect, Schema, Semaphore } from "effect"
-import * as Tool from "./tool"
-import { LSP } from "@/lsp/lsp"
-import { createTwoFilesPatch } from "diff"
-import DESCRIPTION from "./edit.txt"
-import { File } from "../file"
-import { FileWatcher } from "../file/watcher"
-import { Bus } from "../bus"
-import { Format } from "../format"
-import { InstanceState } from "@/effect/instance-state"
-import { Snapshot } from "@/snapshot"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import * as Bom from "@/util/bom"
-import { filterDiagnostics } from "./diagnostics"
-import { ConfigValidation } from "../overlay/config-validation"
-import * as EncodedIO from "../overlay/tool/encoded-io"
-import { buildFileDiff, normalizeLineEndings, detectLineEnding, convertToLineEnding, trimDiff } from "./edit-utils"
-import {
-  SimpleReplacer,
-  LineTrimmedReplacer,
-  BlockAnchorReplacer,
-  WhitespaceNormalizedReplacer,
-  IndentationFlexibleReplacer,
-  EscapeNormalizedReplacer,
-  MultiOccurrenceReplacer,
-  TrimmedBoundaryReplacer,
-  ContextAwareReplacer,
-} from "./edit-replacers"
-
-export { buildFileDiff, trimDiff } from "./edit-utils"
-export type { Replacer } from "./edit-replacers"
-export {
-  SimpleReplacer,
-  LineTrimmedReplacer,
-  BlockAnchorReplacer,
-  WhitespaceNormalizedReplacer,
-  IndentationFlexibleReplacer,
-  EscapeNormalizedReplacer,
-  MultiOccurrenceReplacer,
-  TrimmedBoundaryReplacer,
-  ContextAwareReplacer,
-} from "./edit-replacers"
-
-const locks = new Map<string, Semaphore.Semaphore>()
-
-function lock(filePath: string) {
-  const resolvedFilePath = AppFileSystem.resolve(filePath)
-  const hit = locks.get(resolvedFilePath)
-  if (hit) return hit
-
-  const next = Semaphore.makeUnsafe(1)
-  locks.set(resolvedFilePath, next)
-  return next
-}
-
-export const Parameters = Schema.Struct({
-  filePath: Schema.String.annotate({ description: "The absolute path to the file to modify" }),
-  oldString: Schema.String.annotate({ description: "The text to replace" }),
-  newString: Schema.String.annotate({
-    description: "The text to replace it with (must be different from oldString)",
-  }),
-  replaceAll: Schema.optional(Schema.Boolean).annotate({
-    description: "Replace all occurrences of oldString (default false)",
-  }),
-})
-
-export function replace(content: string, oldString: string, newString: string, replaceAll = false): string {
-  if (oldString === newString) {
-    throw new Error("No changes to apply: oldString and newString are identical.")
-  }
-  let notFound = true
-  for (const replacer of [
-    SimpleReplacer,
-    LineTrimmedReplacer,
-    BlockAnchorReplacer,
-    WhitespaceNormalizedReplacer,
-    IndentationFlexibleReplacer,
-    EscapeNormalizedReplacer,
-    TrimmedBoundaryReplacer,
-    ContextAwareReplacer,
-    MultiOccurrenceReplacer,
-  ]) {
-    for (const search of replacer(content, oldString)) {
-      const index = content.indexOf(search)
-      if (index === -1) continue
-      notFound = false
-      if (replaceAll) {
-        return content.replaceAll(search, newString)
-      }
-      const lastIndex = content.lastIndexOf(search)
-      if (index !== lastIndex) continue
-      return content.substring(0, index) + newString + content.substring(index + search.length)
-    }
-  }
-  if (notFound) {
-    throw new Error(
-      "Could not find oldString in the file. It must match exactly, including whitespace, indentation, and line endings.",
-    )
-  }
-  throw new Error("Found multiple matches for oldString. Provide more surrounding context to make the match unique.")
-}
-
-export const EditTool = Tool.define(
-  "edit",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const afs = yield* AppFileSystem.Service
-    const format = yield* Format.Service
-    const bus = yield* Bus.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (!params.filePath) {
-            throw new Error("filePath is required")
-          }
-
-          if (params.oldString === params.newString) {
-            throw new Error("No changes to apply: oldString and newString are identical.")
-          }
-
-          const instance = yield* InstanceState.context
-          const filePath = path.isAbsolute(params.filePath)
-            ? params.filePath
-            : path.join(instance.directory, params.filePath)
-          yield* assertExternalDirectoryEffect(ctx, filePath)
-
-          let diff = ""
-          let contentOld = ""
-          let contentNew = ""
-          let cachedFilediff: Snapshot.FileDiff | undefined
-          yield* lock(filePath).withPermits(1)(
-            Effect.gen(function* () {
-              if (params.oldString === "") {
-                const existed = yield* afs.existsSafe(filePath)
-                // derive the BOM flag from the detected encoding label instead of the decoded text.
-                const pre = existed ? yield* EncodedIO.read(filePath) : { text: "", encoding: "utf-8" }
-                const source = { bom: pre.encoding === "utf-8-bom", text: pre.text, encoding: pre.encoding }
-                const next = Bom.split(params.newString)
-                const desiredBom = source.bom || next.bom
-                contentOld = source.text
-                contentNew = next.text
-                diff = trimDiff(createTwoFilesPatch(filePath, filePath, contentOld, contentNew))
-                cachedFilediff = buildFileDiff(filePath, contentOld, contentNew)
-                yield* ctx.ask({
-                  permission: "edit",
-                  patterns: [path.relative(instance.worktree, filePath)],
-                  always: ["*"],
-                  metadata: {
-                    filepath: filePath,
-                    diff,
-                    filediff: cachedFilediff,
-                  },
-                })
-                yield* EncodedIO.write(filePath, Bom.join(contentNew, desiredBom), source.encoding)
-                if (yield* format.file(filePath)) {
-                  contentNew = yield* Bom.syncFile(afs, filePath, desiredBom)
-                }
-                yield* bus.publish(File.Event.Edited, { file: filePath })
-                yield* bus.publish(FileWatcher.Event.Updated, {
-                  file: filePath,
-                  event: existed ? "change" : "add",
-                })
-                return
-              }
-
-              const info = yield* afs.stat(filePath).pipe(Effect.catch(() => Effect.succeed(undefined)))
-              if (!info) throw new Error(`File ${filePath} not found`)
-              if (info.type === "Directory") throw new Error(`Path is a directory, not a file: ${filePath}`)
-              // derive the BOM flag from the detected encoding label instead of the decoded text.
-              const pre = yield* EncodedIO.read(filePath)
-              const source = { bom: pre.encoding === "utf-8-bom", text: pre.text, encoding: pre.encoding }
-              contentOld = source.text
-
-              const ending = detectLineEnding(contentOld)
-              const old = convertToLineEnding(normalizeLineEndings(params.oldString), ending)
-              const replacement = convertToLineEnding(normalizeLineEndings(params.newString), ending)
-
-              const next = Bom.split(replace(contentOld, old, replacement, params.replaceAll))
-              const desiredBom = source.bom || next.bom
-              contentNew = next.text
-
-              diff = trimDiff(
-                createTwoFilesPatch(
-                  filePath,
-                  filePath,
-                  normalizeLineEndings(contentOld),
-                  normalizeLineEndings(contentNew),
-                ),
-              )
-              cachedFilediff = buildFileDiff(filePath, contentOld, contentNew)
-              yield* ctx.ask({
-                permission: "edit",
-                patterns: [path.relative(instance.worktree, filePath)],
-                always: ["*"],
-                metadata: {
-                  filepath: filePath,
-                  diff,
-                  filediff: cachedFilediff,
-                },
-              })
-
-              yield* EncodedIO.write(filePath, Bom.join(contentNew, desiredBom), source.encoding)
-              if (yield* format.file(filePath)) {
-                contentNew = yield* Bom.syncFile(afs, filePath, desiredBom)
-              }
-              yield* bus.publish(File.Event.Edited, { file: filePath })
-              yield* bus.publish(FileWatcher.Event.Updated, {
-                file: filePath,
-                event: "change",
-              })
-              diff = trimDiff(
-                createTwoFilesPatch(
-                  filePath,
-                  filePath,
-                  normalizeLineEndings(contentOld),
-                  normalizeLineEndings(contentNew),
-                ),
-              )
-            }).pipe(Effect.orDie),
-          )
-
-          const filediff: Snapshot.FileDiff = cachedFilediff ?? buildFileDiff(filePath, contentOld, contentNew)
-
-          yield* ctx.metadata({
-            metadata: {
-              diff,
-              filediff,
-              diagnostics: {},
-            },
-          })
-
-          let output = "Edit applied successfully."
-          yield* lsp.touchFile(filePath, "document")
-          const diagnostics = yield* lsp.diagnostics()
-          const normalizedFilePath = AppFileSystem.normalizePath(filePath)
-          const block = LSP.Diagnostic.report(filePath, diagnostics[normalizedFilePath] ?? [])
-          if (block) output += `\n\nLSP errors detected in this file, please fix:\n${block}`
-          output += yield* Effect.promise(() => ConfigValidation.check(filePath))
-
-          return {
-            metadata: {
-              diagnostics: filterDiagnostics(diagnostics, [normalizedFilePath]),
-              diff,
-              filediff,
-            },
-            title: `${path.relative(instance.worktree, filePath)}`,
-            output,
-          }
-        }),
-    }
-  }),
-)
+export * from "./file/edit"

package/src/tool/external-directory.ts

@@ -1,55 +1 @@
-import path from "path"
-import { Effect } from "effect"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import { InstanceState } from "@/effect/instance-state"
-import type * as Tool from "./tool"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-
-type Kind = "file" | "directory"
-
-type Options = {
-  bypass?: boolean
-  kind?: Kind
-}
-function root(dir: string) {
-  return path.parse(dir).root === dir
-}
-
-function inside(dir: string, file: string) {
-  return !root(dir) && AppFileSystem.contains(dir, file)
-}
-
-export const assertExternalDirectoryEffect = Effect.fn("Tool.assertExternalDirectory")(function* (
-  ctx: Tool.Context,
-  target?: string,
-  options?: Options,
-) {
-  if (!target) return
-
-  if (options?.bypass) return
-
-  const ins = yield* InstanceState.context
-  const full = process.platform === "win32" ? AppFileSystem.normalizePath(target) : target
-  if (inside(ins.directory, full) || inside(ins.worktree, full)) return
-
-  const kind = options?.kind ?? "file"
-  const dir = kind === "directory" ? full : path.dirname(full)
-  const glob =
-    process.platform === "win32"
-      ? AppFileSystem.normalizePathPattern(path.join(dir, "*"))
-      : path.join(dir, "*").replaceAll("\\", "/")
-
-  yield* ctx.ask({
-    permission: "external_directory",
-    patterns: [glob],
-    always: [glob],
-    metadata: {
-      filepath: full,
-      parentDir: dir,
-    },
-  })
-})
-
-export async function assertExternalDirectory(ctx: Tool.Context, target?: string, options?: Options) {
-  return Effect.runPromise(assertExternalDirectoryEffect(ctx, target, options).pipe(Effect.provide(EffectLogger.layer)))
-}
+export * from "./core/external-directory"