@neurocode-ai/core 1.18.8

package/src/filesystem/search.ts

@@ -0,0 +1,239 @@
+export * as FileSystemSearch from "./search"
+
+import { makeLocationNode } from "../effect/app-node"
+import path from "path"
+import { Context, Effect, Layer, Scope } from "effect"
+import { Fff } from "#fff"
+import fuzzysort from "fuzzysort"
+import { FileSystem } from "../filesystem"
+import { FSUtil } from "../fs-util"
+import { Location } from "../location"
+import { Ripgrep } from "../ripgrep"
+import { RelativePath } from "../schema"
+import { Flag } from "../flag/flag"
+
+export interface Interface {
+  readonly find: (input: FileSystem.FindInput) => Effect.Effect<FileSystem.Entry[]>
+  readonly glob: (input: FileSystem.GlobInput) => Effect.Effect<readonly FileSystem.Entry[]>
+  readonly grep: (input: FileSystem.GrepInput) => Effect.Effect<readonly FileSystem.Match[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/FileSystem/Search") {}
+
+export const ripgrepLayer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const location = yield* Location.Service
+    const ripgrep = yield* Ripgrep.Service
+    const scope = yield* Scope.Scope
+    const state = {
+      files: [] as string[],
+      directories: [] as string[],
+    }
+    const directories = new Set<string>()
+    yield* ripgrep
+      .find({
+        cwd: location.directory,
+        pattern: "*",
+        limit: location.vcs ? Number.MAX_SAFE_INTEGER : 100_000,
+        onEntry: (entry) =>
+          Effect.sync(() => {
+            state.files.push(entry.path)
+            const parts = entry.path.split("/")
+            parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path.sep))
+            state.directories = Array.from(directories)
+          }),
+      })
+      .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
+    return Service.of({
+      glob: (input) =>
+        Effect.gen(function* () {
+          const target = path.resolve(location.directory, input.path ?? ".")
+          const info = yield* fs.stat(target).pipe(Effect.orDie)
+          const cwd = info.type === "File" ? path.dirname(target) : target
+          return yield* ripgrep
+            .glob({
+              cwd,
+              pattern: input.pattern,
+              limit: input.limit ?? Number.MAX_SAFE_INTEGER,
+            })
+            .pipe(
+              Effect.map((result) =>
+                result.map((entry) =>
+                  FileSystem.Entry.make({
+                    ...entry,
+                    path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
+                  }),
+                ),
+              ),
+              Effect.orDie,
+            )
+        }),
+      grep: (input) =>
+        Effect.gen(function* () {
+          const target = path.resolve(location.directory, input.path ?? ".")
+          const info = yield* fs.stat(target).pipe(Effect.orDie)
+          const cwd = info.type === "File" ? path.dirname(target) : target
+          return yield* ripgrep
+            .grep({
+              cwd,
+              pattern: input.pattern,
+              file: info.type === "File" ? path.basename(target) : undefined,
+              include: input.include,
+              limit: input.limit ?? Number.MAX_SAFE_INTEGER,
+            })
+            .pipe(
+              Effect.map((result) =>
+                result.map((match) =>
+                  FileSystem.Match.make({
+                    ...match,
+                    entry: FileSystem.Entry.make({
+                      ...match.entry,
+                      path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path))),
+                    }),
+                  }),
+                ),
+              ),
+              Effect.orDie,
+            )
+        }),
+      find: (input) =>
+        Effect.gen(function* () {
+          const items =
+            input.type === "file"
+              ? state.files
+              : input.type === "directory"
+                ? state.directories
+                : [...state.files, ...state.directories]
+          return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
+            const relative = item.target
+            const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)
+            return FileSystem.Entry.make({
+              path: RelativePath.make(relative),
+              type,
+            })
+          })
+        }),
+    })
+  }),
+)
+
+export const fffLayer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const location = yield* Location.Service
+    const result = yield* Effect.try({
+      try: () =>
+        Fff.create({
+          basePath: location.directory,
+          aiMode: true,
+          disableMmapCache: true,
+          disableContentIndexing: true,
+        }),
+      catch: (cause) => cause,
+    }).pipe(
+      Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))),
+    )
+    if (!result?.ok) {
+      if (result) yield* Effect.logWarning("failed to initialize fff", { error: result.error })
+      return Service.of({
+        find: () => Effect.succeed([]),
+        glob: () => Effect.succeed([]),
+        grep: () => Effect.succeed([]),
+      })
+    }
+    yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()).pipe(Effect.ignore))
+    return Service.of({
+      glob: (input) =>
+        Effect.sync(() => {
+          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
+          const found = result.value.glob(prefix ? `${prefix}/${input.pattern}` : input.pattern, {
+            pageIndex: 0,
+            pageSize: input.limit,
+          })
+          if (!found.ok) throw found.error
+          return found.value.items.map((item) =>
+            FileSystem.Entry.make({
+              path: RelativePath.make(item.relativePath.replaceAll("\\", "/")),
+              type: "file",
+            }),
+          )
+        }),
+      grep: (input) =>
+        Effect.sync(() => {
+          const prefix = input.path?.replaceAll("\\", "/").replace(/\/$/, "")
+          const found = result.value.grep(
+            [prefix ? `${prefix}/**` : undefined, input.include, input.pattern]
+              .filter((value) => value !== undefined)
+              .join(" "),
+            { mode: "regex", pageSize: input.limit, timeBudgetMs: 1_500 },
+          )
+          if (!found.ok) throw found.error
+          return found.value.items.map((match) => {
+            const bytes = Buffer.from(match.lineContent)
+            return FileSystem.Match.make({
+              entry: FileSystem.Entry.make({
+                path: RelativePath.make(match.relativePath.replaceAll("\\", "/")),
+                type: "file",
+              }),
+              line: match.lineNumber,
+              offset: match.byteOffset,
+              text: match.lineContent.length > 2_000 ? match.lineContent.slice(0, 2_000) + "..." : match.lineContent,
+              submatches: match.matchRanges.map(([start, end]) => ({
+                text: bytes.subarray(start, end).toString("utf8"),
+                start,
+                end,
+              })),
+            })
+          })
+        }),
+      find: (input) =>
+        Effect.sync(() => {
+          const options = { pageIndex: 0, pageSize: input.limit ?? 50 }
+          const items = (() => {
+            if (input.type === "file") {
+              const found = result.value.fileSearch(input.query.trim(), options)
+              if (!found.ok) throw found.error
+              return found.value.items.map((item, index) => ({
+                path: item.relativePath,
+                type: "file" as const,
+                score: found.value.scores[index]?.total ?? 0,
+              }))
+            }
+            if (input.type === "directory") {
+              const found = result.value.directorySearch(input.query.trim(), options)
+              if (!found.ok) throw found.error
+              return found.value.items.map((item, index) => ({
+                path: item.relativePath,
+                type: "directory" as const,
+                score: found.value.scores[index]?.total ?? 0,
+              }))
+            }
+            const found = result.value.mixedSearch(input.query.trim(), options)
+            if (!found.ok) throw found.error
+            return found.value.items.map((item, index) => ({
+              path: item.item.relativePath,
+              type: item.type,
+              score: found.value.scores[index]?.total ?? 0,
+            }))
+          })()
+          return items
+            .sort((a, b) => b.score - a.score || a.path.length - b.path.length)
+            .map((item) => {
+              const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "")
+              return FileSystem.Entry.make({
+                path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+                type: item.type,
+              })
+            })
+        }),
+    })
+  }),
+)
+
+const layer = Layer.unwrap(Effect.sync(() => (Flag.NEUROCODE_DISABLE_FFF || !Fff.available() ? ripgrepLayer : fffLayer)))
+
+export const locationLayer = layer
+
+export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node, Location.node, Ripgrep.node] })

package/src/filesystem/watcher.ts

@@ -0,0 +1,140 @@
+export * as Watcher from "./watcher"
+
+// @ts-ignore
+import { createWrapper } from "@parcel/watcher/wrapper"
+import type ParcelWatcher from "@parcel/watcher"
+import { makeLocationNode } from "../effect/app-node"
+import { Cause, Context, Effect, Layer } from "effect"
+import { FileSystemWatcher } from "@neurocode-ai/schema/filesystem-watcher"
+import path from "path"
+import { Config } from "../config"
+import { EventV2 } from "../event"
+import { Flag } from "../flag/flag"
+import { FSUtil } from "../fs-util"
+import { Git } from "../git"
+import { Location } from "../location"
+import { lazy } from "../util/lazy"
+import { Ignore } from "./ignore"
+import { Protected } from "./protected"
+
+declare const NEUROCODE_LIBC: string | undefined
+
+const SUBSCRIBE_TIMEOUT_MS = 10_000
+
+export const Event = FileSystemWatcher.Event
+
+const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
+  try {
+    const libc = typeof NEUROCODE_LIBC === "undefined" ? undefined : NEUROCODE_LIBC
+    const binding = require(
+      `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`,
+    )
+    return createWrapper(binding) as typeof import("@parcel/watcher")
+  } catch {
+    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 relative = path.relative(dir, item)
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
+  })
+}
+
+export const hasNativeBinding = () => !!watcher()
+
+export interface Interface {}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/FileWatcher") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    if (yield* Flag.NEUROCODE_EXPERIMENTAL_DISABLE_FILEWATCHER) return Service.of({})
+
+    const backend = getBackend()
+    const location = yield* Location.Service
+    if (!backend) {
+      yield* Effect.logError("watcher backend not supported", {
+        directory: location.directory,
+        platform: process.platform,
+      })
+      return Service.of({})
+    }
+
+    const w = watcher()
+    if (!w) return Service.of({})
+
+    yield* Effect.logInfo("watcher backend", { directory: location.directory, platform: process.platform, backend })
+    const events = yield* EventV2.Service
+    const fs = yield* FSUtil.Service
+    const git = yield* Git.Service
+    const context = yield* Effect.context()
+    const runFork = Effect.runForkWith(context)
+    const subscriptions: ParcelWatcher.AsyncSubscription[] = []
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(() => Promise.allSettled(subscriptions.map((subscription) => subscription.unsubscribe()))),
+    )
+
+    const callback: ParcelWatcher.SubscribeCallback = (_error, updates) => {
+      for (const update of updates) {
+        if (update.type === "create") runFork(events.publish(Event.Updated, { file: update.path, event: "add" }))
+        if (update.type === "update") runFork(events.publish(Event.Updated, { file: update.path, event: "change" }))
+        if (update.type === "delete") runFork(events.publish(Event.Updated, { file: update.path, event: "unlink" }))
+      }
+    }
+
+    const subscribe = (directory: string, ignore: string[]) => {
+      const pending = w.subscribe(directory, callback, { ignore, backend })
+      return Effect.promise(() => pending).pipe(
+        Effect.tap((subscription) => Effect.sync(() => subscriptions.push(subscription))),
+        Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
+        Effect.catchCause((cause) => {
+          pending.then((subscription) => subscription.unsubscribe()).catch(() => {})
+          return Effect.logError("failed to subscribe", { directory, cause: Cause.pretty(cause) })
+        }),
+      )
+    }
+
+    const config = (yield* (yield* Config.Service).entries())
+      .filter((entry): entry is Config.Document => entry.type === "document")
+      .flatMap((item) => item.info.watcher?.ignore ?? [])
+    if (location.vcs && (yield* Flag.NEUROCODE_EXPERIMENTAL_FILEWATCHER)) {
+      yield* Effect.forkScoped(
+        subscribe(location.directory, [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)]),
+      )
+    }
+
+    if (location.vcs?.type === "git") {
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
+      const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved))) : undefined
+      if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
+        const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
+          (entry) => (entry.name === "HEAD" ? [] : [entry.name]),
+        )
+        yield* Effect.forkScoped(subscribe(vcs, ignore))
+      }
+    }
+
+    return Service.of({})
+  }).pipe(
+    Effect.catchCause((cause) => {
+      return Effect.logError("failed to init watcher service", { cause: Cause.pretty(cause) }).pipe(
+        Effect.as(Service.of({})),
+      )
+    }),
+  ),
+)
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, Location.node, Config.node, Git.node, EventV2.node],
+})

package/src/filesystem.ts

@@ -0,0 +1,118 @@
+export * as FileSystem from "./filesystem"
+
+import { makeLocationNode } from "./effect/app-node"
+import path from "path"
+import { Context, Effect, Layer, Schema } from "effect"
+import { FSUtil } from "./fs-util"
+import { Location } from "./location"
+import { PositiveInt, RelativePath } from "./schema"
+import { FileSystemSearch } from "./filesystem/search"
+import { Entry, FileSystem, FindInput, Match } from "@neurocode-ai/schema/filesystem"
+export { Entry, Match, Submatch } from "@neurocode-ai/schema/filesystem"
+
+export const ReadInput = Schema.Struct({
+  path: RelativePath,
+})
+export type ReadInput = typeof ReadInput.Type
+
+export const Content = Schema.Struct({
+  uri: Schema.String,
+  name: Schema.String.pipe(Schema.optional),
+  content: Schema.String,
+  encoding: Schema.Literals(["utf8", "base64"]),
+  mime: Schema.String,
+}).annotate({ identifier: "FileSystem.Content" })
+export type Content = typeof Content.Type
+
+export const ListInput = Schema.Struct({
+  path: RelativePath.pipe(Schema.optional),
+})
+export type ListInput = typeof ListInput.Type
+
+export { FindInput }
+
+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 const Event = FileSystem.Event
+
+export interface Interface {
+  readonly read: (input: ReadInput) => Effect.Effect<{ readonly content: Uint8Array; readonly mime: string }>
+  readonly list: (input?: ListInput) => Effect.Effect<Entry[]>
+  readonly find: (input: FindInput) => Effect.Effect<Entry[]>
+  readonly glob: (input: GlobInput) => Effect.Effect<readonly Entry[]>
+  readonly grep: (input: GrepInput) => Effect.Effect<readonly Match[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/v2/FileSystem") {}
+
+const baseLayer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const location = yield* Location.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 ?? ".")
+      if (!FSUtil.contains(location.directory, absolute))
+        return yield* Effect.die(new Error("Path escapes the location"))
+      const real = yield* fs.realPath(absolute).pipe(Effect.orDie)
+      if (!FSUtil.contains(root, real)) return yield* Effect.die(new Error("Path escapes the location"))
+      return { absolute, real, directory: location.directory, root }
+    })
+    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)
+        if (info.type !== "File") return yield* Effect.die(new Error("Path is not a file"))
+        return {
+          content: yield* fs.readFile(target.real).pipe(Effect.orDie),
+          mime: FSUtil.mimeType(target.real),
+        }
+      }),
+      list: Effect.fn("FileSystem.list")(function* (input = {}) {
+        const target = yield* resolve(input.path)
+        const info = yield* fs.stat(target.real).pipe(Effect.orDie)
+        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.map((items) =>
+            items
+              .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 [
+                  Entry.make({
+                    path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+                    type: item.type,
+                  }),
+                ]
+              })
+              .sort((a, b) => (a.type === b.type ? a.path.localeCompare(b.path) : a.type === "directory" ? -1 : 1)),
+          ),
+        )
+      }),
+    })
+  }),
+)
+
+export const node = makeLocationNode({
+  service: Service,
+  layer: baseLayer,
+  deps: [FSUtil.node, Location.node, FileSystemSearch.node],
+})

package/src/flag/flag.ts

@@ -0,0 +1,78 @@
+import { Config } from "effect"
+
+export function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+const copy = process.env["NEUROCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"]
+const fff = process.env["NEUROCODE_DISABLE_FFF"]
+
+function enabledByExperimental(key: string) {
+  return process.env[key] === undefined ? truthy("NEUROCODE_EXPERIMENTAL") : truthy(key)
+}
+
+export const Flag = {
+  OTEL_EXPORTER_OTLP_ENDPOINT: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"],
+  OTEL_EXPORTER_OTLP_HEADERS: process.env["OTEL_EXPORTER_OTLP_HEADERS"],
+
+  NEUROCODE_AUTO_HEAP_SNAPSHOT: truthy("NEUROCODE_AUTO_HEAP_SNAPSHOT"),
+  NEUROCODE_GIT_BASH_PATH: process.env["NEUROCODE_GIT_BASH_PATH"],
+  NEUROCODE_CONFIG: process.env["NEUROCODE_CONFIG"],
+  NEUROCODE_CONFIG_CONTENT: process.env["NEUROCODE_CONFIG_CONTENT"],
+  NEUROCODE_DISABLE_AUTOUPDATE: truthy("NEUROCODE_DISABLE_AUTOUPDATE"),
+  NEUROCODE_ALWAYS_NOTIFY_UPDATE: truthy("NEUROCODE_ALWAYS_NOTIFY_UPDATE"),
+  NEUROCODE_DISABLE_PRUNE: truthy("NEUROCODE_DISABLE_PRUNE"),
+  NEUROCODE_DISABLE_TERMINAL_TITLE: truthy("NEUROCODE_DISABLE_TERMINAL_TITLE"),
+  NEUROCODE_SHOW_TTFD: truthy("NEUROCODE_SHOW_TTFD"),
+  NEUROCODE_DISABLE_AUTOCOMPACT: truthy("NEUROCODE_DISABLE_AUTOCOMPACT"),
+  NEUROCODE_DISABLE_MODELS_FETCH: truthy("NEUROCODE_DISABLE_MODELS_FETCH"),
+  NEUROCODE_DISABLE_MOUSE: truthy("NEUROCODE_DISABLE_MOUSE"),
+  NEUROCODE_FAKE_VCS: process.env["NEUROCODE_FAKE_VCS"],
+  NEUROCODE_SERVER_PASSWORD: process.env["NEUROCODE_SERVER_PASSWORD"],
+  NEUROCODE_SERVER_USERNAME: process.env["NEUROCODE_SERVER_USERNAME"],
+  NEUROCODE_DISABLE_FFF: fff === undefined ? process.platform === "win32" : truthy("NEUROCODE_DISABLE_FFF"),
+
+  // Experimental
+  NEUROCODE_EXPERIMENTAL_FILEWATCHER: Config.boolean("NEUROCODE_EXPERIMENTAL_FILEWATCHER").pipe(
+    Config.withDefault(false),
+  ),
+  NEUROCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: Config.boolean("NEUROCODE_EXPERIMENTAL_DISABLE_FILEWATCHER").pipe(
+    Config.withDefault(false),
+  ),
+  NEUROCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT:
+    copy === undefined ? process.platform === "win32" : truthy("NEUROCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"),
+  NEUROCODE_MODELS_URL: process.env["NEUROCODE_MODELS_URL"],
+  NEUROCODE_MODELS_PATH: process.env["NEUROCODE_MODELS_PATH"],
+  NEUROCODE_DB: process.env["NEUROCODE_DB"],
+
+  NEUROCODE_WORKSPACE_ID: process.env["NEUROCODE_WORKSPACE_ID"],
+  NEUROCODE_EXPERIMENTAL_WORKSPACES: enabledByExperimental("NEUROCODE_EXPERIMENTAL_WORKSPACES"),
+
+  // Evaluated at access time (not module load) because tests, the CLI, and
+  // external tooling set these env vars at runtime.
+  get NEUROCODE_DISABLE_PROJECT_CONFIG() {
+    return truthy("NEUROCODE_DISABLE_PROJECT_CONFIG")
+  },
+  get NEUROCODE_EXPERIMENTAL_REFERENCES() {
+    return enabledByExperimental("NEUROCODE_EXPERIMENTAL_REFERENCES")
+  },
+  get NEUROCODE_TUI_CONFIG() {
+    return process.env["NEUROCODE_TUI_CONFIG"]
+  },
+  get NEUROCODE_CONFIG_DIR() {
+    return process.env["NEUROCODE_CONFIG_DIR"]
+  },
+  get NEUROCODE_PURE() {
+    return truthy("NEUROCODE_PURE")
+  },
+  get NEUROCODE_PERMISSION() {
+    return process.env["NEUROCODE_PERMISSION"]
+  },
+  get NEUROCODE_PLUGIN_META_FILE() {
+    return process.env["NEUROCODE_PLUGIN_META_FILE"]
+  },
+  get NEUROCODE_CLIENT() {
+    return process.env["NEUROCODE_CLIENT"] ?? "cli"
+  },
+}