@neurocode-ai/core 1.18.8

package/src/file-mutation.ts

@@ -0,0 +1,207 @@
+export * as FileMutation from "./file-mutation"
+
+import { makeLocationNode } from "./effect/app-node"
+import { Context, Effect, Layer, Schema } from "effect"
+import { dirname } from "path"
+import { KeyedMutex } from "./effect/keyed-mutex"
+import { FSUtil } from "./fs-util"
+
+export interface Target {
+  readonly canonical: string
+  readonly resource: string
+}
+
+export interface WriteInput {
+  readonly target: Target
+  readonly content: string | Uint8Array
+}
+
+export interface TextWriteInput {
+  readonly target: Target
+  readonly content: string
+}
+
+export interface ConditionalWriteInput extends WriteInput {
+  readonly expected: Uint8Array
+}
+
+export interface RemoveInput {
+  readonly target: Target
+}
+
+export class StaleContentError extends Schema.TaggedErrorClass<StaleContentError>()("FileMutation.StaleContentError", {
+  path: Schema.String,
+}) {}
+
+export class TargetExistsError extends Schema.TaggedErrorClass<TargetExistsError>()("FileMutation.TargetExistsError", {
+  path: Schema.String,
+}) {}
+
+export interface WriteResult {
+  readonly operation: "write"
+  readonly target: string
+  readonly resource: string
+  readonly existed: boolean
+}
+
+export interface RemoveResult {
+  readonly operation: "remove"
+  readonly target: string
+  readonly resource: string
+  readonly existed: boolean
+}
+
+export interface Interface {
+  /** Create without replacing an existing target. */
+  readonly create: (input: WriteInput) => Effect.Effect<WriteResult, TargetExistsError | FSUtil.Error>
+  readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
+  /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
+  readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
+  /** Commit only if an existing target still has the expected bytes. */
+  readonly writeIfUnchanged: (
+    input: ConditionalWriteInput,
+  ) => Effect.Effect<WriteResult, StaleContentError | FSUtil.Error>
+  readonly remove: (input: RemoveInput) => Effect.Effect<RemoveResult, FSUtil.Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/FileMutation") {}
+
+/**
+ * Serialize file changes by canonical target. Conditional writes compare and
+ * write under the same process-local lock so cooperating NeuroCode mutations do
+ * not overwrite changes made from the same stale content.
+ */
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const locks = KeyedMutex.makeUnsafe<string>()
+    const withTargetLock =
+      (target: Target) =>
+      <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        locks.withLock(target.canonical)(Effect.uninterruptible(effect))
+
+    const writeResult = (target: Target, existed: boolean): WriteResult => ({
+      operation: "write",
+      target: target.canonical,
+      resource: target.resource,
+      existed,
+    })
+
+    const removeResult = (target: Target, existed: boolean): RemoveResult => ({
+      operation: "remove",
+      target: target.canonical,
+      resource: target.resource,
+      existed,
+    })
+
+    const write = Effect.fn("FileMutation.write")((input: WriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const existed = yield* fs.exists(input.target.canonical)
+          yield* fs.writeWithDirs(input.target.canonical, input.content)
+          return writeResult(input.target, existed)
+        }),
+      ),
+    )
+
+    const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input: TextWriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const next = splitBom(input.content)
+          const current = yield* fs
+            .readFile(input.target.canonical)
+            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
+          yield* fs.writeWithDirs(
+            input.target.canonical,
+            joinBom(next.text, Boolean(current && hasUtf8Bom(current)) || next.bom),
+          )
+          return writeResult(input.target, current !== undefined)
+        }),
+      ),
+    )
+
+    const create = Effect.fn("FileMutation.create")((input: WriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const write =
+            typeof input.content === "string"
+              ? fs.writeFileString(input.target.canonical, input.content, { flag: "wx" })
+              : fs.writeFile(input.target.canonical, input.content, { flag: "wx" })
+          yield* write.pipe(
+            Effect.catchReason("PlatformError", "NotFound", () =>
+              fs.ensureDir(dirname(input.target.canonical)).pipe(Effect.andThen(write)),
+            ),
+            Effect.catchReason("PlatformError", "AlreadyExists", () =>
+              Effect.fail(new TargetExistsError({ path: input.target.canonical })),
+            ),
+          )
+          return writeResult(input.target, false)
+        }),
+      ),
+    )
+
+    const writeIfUnchanged = Effect.fn("FileMutation.writeIfUnchanged")((input: ConditionalWriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const current = yield* fs.readFile(input.target.canonical)
+          if (!sameBytes(current, input.expected)) {
+            return yield* new StaleContentError({ path: input.target.canonical })
+          }
+          yield* typeof input.content === "string"
+            ? fs.writeFileString(input.target.canonical, input.content)
+            : fs.writeFile(input.target.canonical, input.content)
+          return writeResult(input.target, true)
+        }),
+      ),
+    )
+
+    const remove = Effect.fn("FileMutation.remove")((input: RemoveInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const existed = yield* fs.remove(input.target.canonical).pipe(
+            Effect.as(true),
+            Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)),
+          )
+          return removeResult(input.target, existed)
+        }),
+      ),
+    )
+
+    return Service.of({ create, write, writeTextPreservingBom, writeIfUnchanged, remove })
+  }),
+)
+
+function splitBom(text: string) {
+  const stripped = text.replace(/^\uFEFF+/, "")
+  return { bom: stripped.length !== text.length, text: stripped }
+}
+
+function joinBom(text: string, bom: boolean) {
+  const stripped = splitBom(text).text
+  return bom ? `\uFEFF${stripped}` : stripped
+}
+
+function hasUtf8Bom(content: Uint8Array) {
+  return content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
+}
+
+function sameBytes(left: Uint8Array, right: Uint8Array) {
+  if (left.length !== right.length) return false
+  return left.every((byte, index) => byte === right[index])
+}
+
+export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
+
+/**
+ * Deferred until the corresponding V2 integrations exist.
+ */
+// TODO: Add formatter integration after V2 formatter runtime exists.
+// TODO: Publish watcher/file-edit events after V2 watcher integration exists.
+// TODO: Add snapshots / undo after V2 snapshot design exists.
+// TODO: Notify LSP and collect diagnostics after V2 LSP runtime exists.
+// TODO: Design multi-file transactions / rollback if apply_patch needs atomic edits.
+// Until then, edits are sequential and report partial application.
+// TODO: Define crash recovery and idempotency for side effects between Tool.Called and durable settlement.

package/src/file.ts

@@ -0,0 +1,6 @@
+export * as File from "./file"
+
+import { Revert } from "@neurocode-ai/schema/revert"
+
+export const Diff = Revert.FileDiff
+export type Diff = typeof Diff.Type

package/src/filesystem/fff.bun.ts

@@ -0,0 +1,140 @@
+import {
+  FileFinder,
+  type DirItem,
+  type DirSearchResult,
+  type FileItem,
+  type GrepCursor,
+  type GrepMatch,
+  type GrepResult,
+  type InitOptions,
+  type MixedItem,
+  type MixedSearchResult,
+  type SearchResult,
+} from "@ff-labs/fff-bun"
+
+declare global {
+  const FFF_LIBC: "gnu" | "musl"
+}
+
+export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
+
+export type Init = InitOptions
+
+export interface Search {
+  items: FileItem[]
+  scores: SearchResult["scores"]
+  totalMatched: number
+  totalFiles: number
+}
+
+export interface DirSearch {
+  items: DirItem[]
+  scores: DirSearchResult["scores"]
+  totalMatched: number
+  totalDirs: number
+}
+
+export interface MixedSearch {
+  items: MixedItem[]
+  scores: MixedSearchResult["scores"]
+  totalMatched: number
+  totalFiles: number
+  totalDirs: number
+}
+
+export type File = FileItem
+export type Directory = DirItem
+export type Mixed = MixedItem
+export type Cursor = GrepCursor | null
+export type Hit = GrepMatch
+
+export interface Grep {
+  items: GrepResult["items"]
+  totalMatched: number
+  totalFilesSearched: number
+  totalFiles: number
+  filteredFileCount: number
+  nextCursor: Cursor
+  regexFallbackError?: string
+}
+
+export interface Picker {
+  destroy(): void
+  isScanning(): boolean
+  waitForScan(timeoutMs?: number): Promise<Result<boolean>>
+  refreshGitStatus(): Result<number>
+  fileSearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
+  glob(
+    pattern: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
+  directorySearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<DirSearch>
+  mixedSearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<MixedSearch>
+  grep(
+    query: string,
+    opts?: {
+      mode?: "plain" | "regex" | "fuzzy"
+      maxMatchesPerFile?: number
+      timeBudgetMs?: number
+      beforeContext?: number
+      afterContext?: number
+      cursor?: Cursor
+      pageSize?: number
+    },
+  ): Result<Grep>
+  trackQuery(query: string, file: string): Result<boolean>
+  getHistoricalQuery(offset: number): Result<string | null>
+}
+
+export function available() {
+  return FileFinder.isAvailable()
+}
+
+export function create(opts: Init): Result<Picker> {
+  const made = FileFinder.create(opts)
+  if (!made.ok) return made
+  const pick = made.value
+  return {
+    ok: true,
+    value: {
+      destroy: () => pick.destroy(),
+      isScanning: () => pick.isScanning(),
+      waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
+      refreshGitStatus: () => pick.refreshGitStatus(),
+      fileSearch: (query, next) => pick.fileSearch(query, next),
+      glob: (pattern, next) => pick.glob(pattern, next),
+      directorySearch: (query, next) => pick.directorySearch(query, next),
+      mixedSearch: (query, next) => pick.mixedSearch(query, next),
+      grep: (query, next) => pick.grep(query, next),
+      trackQuery: (query, file) => pick.trackQuery(query, file),
+      getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
+    },
+  }
+}
+
+export * as Fff from "./fff.bun"

package/src/filesystem/fff.node.ts

@@ -0,0 +1,138 @@
+export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
+
+export interface Init {
+  basePath: string
+  frecencyDbPath?: string
+  historyDbPath?: string
+  useUnsafeNoLock?: boolean
+  disableMmapCache?: boolean
+  disableContentIndexing?: boolean
+  disableWatch?: boolean
+  aiMode?: boolean
+  logFilePath?: string
+  logLevel?: "trace" | "debug" | "info" | "warn" | "error"
+  enableFsRootScanning?: boolean
+  enableHomeDirScanning?: boolean
+}
+
+export interface File {
+  relativePath: string
+  fileName: string
+  modified: number
+}
+
+export interface Directory {
+  relativePath: string
+  dirName: string
+  maxAccessFrecency: number
+}
+
+export type Mixed = { type: "file"; item: File } | { type: "directory"; item: Directory }
+
+export interface Search {
+  items: File[]
+  scores: Array<{ total: number }>
+  totalMatched: number
+  totalFiles: number
+}
+
+export interface DirSearch {
+  items: Directory[]
+  scores: Array<{ total: number }>
+  totalMatched: number
+  totalDirs: number
+}
+
+export interface MixedSearch {
+  items: Mixed[]
+  scores: Array<{ total: number }>
+  totalMatched: number
+  totalFiles: number
+  totalDirs: number
+}
+
+export type Cursor = null
+
+export interface Hit {
+  relativePath: string
+  fileName: string
+  lineNumber: number
+  byteOffset: number
+  lineContent: string
+  matchRanges: [number, number][]
+  contextBefore?: string[]
+  contextAfter?: string[]
+}
+
+export interface Grep {
+  items: Hit[]
+  totalMatched: number
+  totalFilesSearched: number
+  totalFiles: number
+  filteredFileCount: number
+  nextCursor: Cursor
+  regexFallbackError?: string
+}
+
+export interface Picker {
+  destroy(): void
+  isScanning(): boolean
+  waitForScan(timeoutMs?: number): Promise<Result<boolean>>
+  refreshGitStatus(): Result<number>
+  fileSearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
+  glob(
+    pattern: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<Search>
+  directorySearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<DirSearch>
+  mixedSearch(
+    query: string,
+    opts?: {
+      currentFile?: string
+      pageIndex?: number
+      pageSize?: number
+    },
+  ): Result<MixedSearch>
+  grep(
+    query: string,
+    opts?: {
+      mode?: "plain" | "regex" | "fuzzy"
+      maxMatchesPerFile?: number
+      timeBudgetMs?: number
+      beforeContext?: number
+      afterContext?: number
+      cursor?: Cursor
+      pageSize?: number
+    },
+  ): Result<Grep>
+  trackQuery(query: string, file: string): Result<boolean>
+  getHistoricalQuery(offset: number): Result<string | null>
+}
+
+export function available() {
+  return false
+}
+
+export function create(_opts: Init): Result<Picker> {
+  return { ok: false, error: "fff unavailable on node runtime" }
+}
+
+export * as Fff from "./fff.node"

package/src/filesystem/ignore.ts

@@ -0,0 +1,67 @@
+import { Glob } from "../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",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+  "**/logs/**",
+  "**/tmp/**",
+  "**/temp/**",
+  "**/*.log",
+  "**/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 (const part of parts) {
+    if (FOLDERS.has(part)) return true
+  }
+
+  for (const pattern of [...FILES, ...(opts?.extra || [])]) {
+    if (Glob.match(pattern, filepath)) return true
+  }
+
+  return false
+}
+
+export * as Ignore from "./ignore"

package/src/filesystem/protected.ts

@@ -0,0 +1,53 @@
+import os from "os"
+import path from "path"
+
+const home = os.homedir()
+
+const DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "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((name) => path.join(home, name)),
+      ...DARWIN_LIBRARY.map((name) => path.join(home, "Library", name)),
+      ...DARWIN_ROOT,
+    ]
+  if (process.platform === "win32") return WIN32_HOME.map((name) => path.join(home, name))
+  return []
+}
+
+export * as Protected from "./protected"