@prover-coder-ai/context-doc 1.0.18 → 1.0.19

package/eslint.effect-ts-check.config.mjs

@@ -1,220 +0,0 @@
-// CHANGE: add Effect-TS compliance lint profile
-// WHY: detect current deviations from strict Effect-TS guidance
-// QUOTE(TZ): n/a
-// REF: AGENTS.md Effect-TS compliance checks
-// SOURCE: n/a
-// PURITY: SHELL
-// EFFECT: eslint config
-// INVARIANT: config only flags explicit policy deviations
-// COMPLEXITY: O(1)/O(1)
-import eslintComments from "@eslint-community/eslint-plugin-eslint-comments"
-import globals from "globals"
-import tseslint from "typescript-eslint"
-
-const restrictedImports = [
-  {
-    name: "node:fs",
-    message: "Use @effect/platform FileSystem instead of node:fs."
-  },
-  {
-    name: "fs",
-    message: "Use @effect/platform FileSystem instead of fs."
-  },
-  {
-    name: "node:fs/promises",
-    message: "Use @effect/platform FileSystem instead of node:fs/promises."
-  },
-  {
-    name: "node:path/posix",
-    message: "Use @effect/platform Path instead of node:path/posix."
-  },
-  {
-    name: "node:path",
-    message: "Use @effect/platform Path instead of node:path."
-  },
-  {
-    name: "path",
-    message: "Use @effect/platform Path instead of path."
-  },
-  {
-    name: "node:child_process",
-    message: "Use @effect/platform Command instead of node:child_process."
-  },
-  {
-    name: "child_process",
-    message: "Use @effect/platform Command instead of child_process."
-  },
-  {
-    name: "node:process",
-    message: "Use @effect/platform Runtime instead of node:process."
-  },
-  {
-    name: "process",
-    message: "Use @effect/platform Runtime instead of process."
-  }
-]
-
-const restrictedSyntaxBase = [
-  {
-    selector: "SwitchStatement",
-    message: "Switch is forbidden. Use Match.exhaustive."
-  },
-  {
-    selector: "TryStatement",
-    message: "Avoid try/catch in product code. Use Effect.try / Effect.catch*."
-  },
-  {
-    selector: "AwaitExpression",
-    message: "Avoid await. Use Effect.gen / Effect.flatMap."
-  },
-  {
-    selector: "FunctionDeclaration[async=true], FunctionExpression[async=true], ArrowFunctionExpression[async=true]",
-    message: "Avoid async/await. Use Effect.gen / Effect.tryPromise."
-  },
-  {
-    selector: "NewExpression[callee.name='Promise']",
-    message: "Avoid new Promise. Use Effect.async / Effect.tryPromise."
-  },
-  {
-    selector: "CallExpression[callee.object.name='Promise']",
-    message: "Avoid Promise.*. Use Effect combinators."
-  },
-  {
-    selector: "CallExpression[callee.name='require']",
-    message: "Avoid require(). Use ES module imports."
-  },
-  {
-    selector: "TSAsExpression",
-    message: "Casting is only allowed in src/core/axioms.ts."
-  },
-  {
-    selector: "TSTypeAssertion",
-    message: "Casting is only allowed in src/core/axioms.ts."
-  },
-  {
-    selector: "CallExpression[callee.name='makeFilesystemService']",
-    message: "Do not instantiate FilesystemService directly. Provide Layer and access via Tag."
-  },
-  {
-    selector: "CallExpression[callee.property.name='catchAll']",
-    message: "Avoid catchAll that discards typed errors; map or propagate explicitly."
-  }
-]
-
-const restrictedSyntaxCore = [
-  ...restrictedSyntaxBase,
-  {
-    selector: "TSUnknownKeyword",
-    message: "unknown is allowed only at shell boundaries with decoding."
-  },
-  {
-    selector: "CallExpression[callee.property.name='runSyncExit']",
-    message: "Effect.runSyncExit is shell-only. Move to a runner."
-  },
-  {
-    selector: "CallExpression[callee.property.name='runSync']",
-    message: "Effect.runSync is shell-only. Move to a runner."
-  },
-  {
-    selector: "CallExpression[callee.property.name='runPromise']",
-    message: "Effect.runPromise is shell-only. Move to a runner."
-  }
-]
-
-const restrictedSyntaxCoreNoAs = [
-  ...restrictedSyntaxCore.filter((rule) =>
-    rule.selector !== "TSAsExpression" && rule.selector !== "TSTypeAssertion"
-  )
-]
-
-const restrictedSyntaxBaseNoServiceFactory = [
-  ...restrictedSyntaxBase.filter((rule) =>
-    rule.selector !== "CallExpression[callee.name='makeFilesystemService']"
-  )
-]
-
-export default tseslint.config(
-  {
-    name: "effect-ts-compliance-check",
-    files: ["src/**/*.ts", "scripts/**/*.ts"],
-    languageOptions: {
-      parser: tseslint.parser,
-      globals: { ...globals.node }
-    },
-    plugins: {
-      "@typescript-eslint": tseslint.plugin,
-      "eslint-comments": eslintComments
-    },
-    rules: {
-      "no-console": "error",
-      "no-restricted-imports": ["error", {
-        paths: restrictedImports,
-        patterns: [
-          {
-            group: ["node:*"],
-            message: "Do not import from node:* directly. Use @effect/platform-node or @effect/platform services."
-          }
-        ]
-      }],
-      "no-restricted-syntax": ["error", ...restrictedSyntaxBase],
-      "@typescript-eslint/no-explicit-any": "error",
-      "@typescript-eslint/ban-ts-comment": ["error", {
-        "ts-ignore": true,
-        "ts-nocheck": true,
-        "ts-check": false,
-        "ts-expect-error": true
-      }],
-      "@typescript-eslint/no-restricted-types": ["error", {
-        types: {
-          Promise: {
-            message: "Avoid Promise in types. Use Effect.Effect<A, E, R>."
-          },
-          "Promise<*>": {
-            message: "Avoid Promise<T>. Use Effect.Effect<T, E, R>."
-          }
-        }
-      }],
-      "eslint-comments/no-use": "error",
-      "eslint-comments/no-unlimited-disable": "error",
-      "eslint-comments/disable-enable-pair": "error",
-      "eslint-comments/no-unused-disable": "error"
-    }
-  },
-  {
-    name: "effect-ts-compliance-core",
-    files: ["src/core/**/*.ts"],
-    rules: {
-      "no-restricted-syntax": ["error", ...restrictedSyntaxCore],
-      "no-restricted-imports": ["error", {
-        paths: restrictedImports,
-        patterns: [
-          {
-            group: [
-              "../shell/**",
-              "../../shell/**",
-              "../../../shell/**",
-              "./shell/**",
-              "src/shell/**",
-              "shell/**"
-            ],
-            message: "CORE must not import from SHELL."
-          }
-        ]
-      }]
-    }
-  },
-  {
-    name: "effect-ts-compliance-axioms",
-    files: ["src/core/axioms.ts"],
-    rules: {
-      "no-restricted-syntax": ["error", ...restrictedSyntaxCoreNoAs]
-    }
-  },
-  {
-    name: "effect-ts-compliance-filesystem-service",
-    files: ["src/shell/services/filesystem.ts"],
-    rules: {
-      "no-restricted-syntax": ["error", ...restrictedSyntaxBaseNoServiceFactory]
-    }
-  }
-)

package/linter.config.json

@@ -1,33 +0,0 @@
-{
-	"priorityLevels": [
-		{
-			"level": 1,
-			"name": "Critical Compiler Errors",
-			"rules": [
-				"ts(2835)",
-				"ts(2307)",
-				"@prover-coder-ai/suggest-members/suggest-members",
-				"@prover-coder-ai/suggest-members/suggest-imports",
-				"@prover-coder-ai/suggest-members/suggest-module-paths",
-				"@prover-coder-ai/suggest-members/suggest-exports",
-				"@prover-coder-ai/suggest-members/suggest-missing-names",
-				"@typescript-eslint/no-explicit-any"
-			]
-		},
-		{
-			"level": 2,
-			"name": "Critical Compiler Errors",
-			"rules": ["all"]
-		},
-		{
-			"level": 3,
-			"name": "Critical Compiler Errors (Code must follow Clean Code and best practices)",
-			"rules": ["max-lines-per-function", "max-lines"]
-		},
-		{
-			"level": 4,
-			"name": "Critical Compiler Errors (Code must follow Clean Code and best practices)",
-			"rules": ["complexity", "max-params", "max-depth"]
-		}
-	]
-}

package/src/app/main.ts

@@ -1,29 +0,0 @@
-import { NodeContext, NodeRuntime } from "@effect/platform-node"
-import { Effect, Layer, pipe } from "effect"
-
-import { CryptoServiceLive } from "../shell/services/crypto.js"
-import { FileSystemLive } from "../shell/services/file-system.js"
-import { RuntimeEnvLive } from "../shell/services/runtime-env.js"
-import { program } from "./program.js"
-
-// CHANGE: run the sync program through the Node runtime with all live layers
-// WHY: provide platform services and shell dependencies in one place
-// QUOTE(TZ): "SHELL: Все эффекты изолированы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall env: provide(env) -> runMain(program)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, RuntimeEnv | FileSystemService | CryptoService | Path>
-// INVARIANT: program executed with NodeContext + live services
-// COMPLEXITY: O(1)/O(1)
-const main = pipe(
-  program,
-  Effect.provide(
-    Layer.provideMerge(
-      Layer.mergeAll(RuntimeEnvLive, FileSystemLive, CryptoServiceLive),
-      NodeContext.layer
-    )
-  )
-)
-
-NodeRuntime.runMain(main)

package/src/app/program.ts

@@ -1,32 +0,0 @@
-import { Effect, pipe } from "effect"
-
-import { readSyncOptions } from "../shell/cli.js"
-import { buildSyncProgram } from "../shell/sync/index.js"
-
-/**
- * Compose the knowledge sync CLI as a single effect.
- *
- * @returns Effect that runs multi-source sync in sequence.
- *
- * @pure false - reads argv and performs filesystem IO
- * @effect RuntimeEnv, FileSystemService, CryptoService, Path
- * @invariant forall opts: buildSyncProgram(opts) runs each source exactly once
- * @precondition true
- * @postcondition sources are synced or skipped with logs
- * @complexity O(n) where n = number of files scanned
- * @throws Never - all errors are typed in the Effect error channel
- */
-// CHANGE: rewire program to knowledge-sync orchestration
-// WHY: replace greeting demo with the fully effectful sync pipeline
-// QUOTE(TZ): "Возьми прошлый ... код и перепиши его полностью"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall a: parse(a) -> run(sync(a))
-// PURITY: SHELL
-// EFFECT: Effect<void, never, RuntimeEnv | FileSystemService | CryptoService | Path>
-// INVARIANT: sync sources run in deterministic order
-// COMPLEXITY: O(n)/O(n)
-export const program = pipe(
-  readSyncOptions,
-  Effect.flatMap((options) => buildSyncProgram(options))
-)

package/src/core/knowledge.ts

@@ -1,115 +0,0 @@
-import { Option, pipe } from "effect"
-
-export type JsonPrimitive = string | number | boolean | null
-export type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | JsonRecord
-export interface JsonRecord {
-  readonly [key: string]: JsonValue
-}
-
-export interface ProjectLocator {
-  readonly normalizedCwd: string
-  readonly isWithinRoot: (candidate: string) => boolean
-}
-
-interface RecordMetadata {
-  readonly cwd: Option.Option<string>
-}
-
-const isJsonRecord = (value: JsonValue): value is JsonRecord =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const pickString = (record: JsonRecord, key: string): Option.Option<string> => {
-  const candidate = record[key]
-  return Option.fromNullable(typeof candidate === "string" ? candidate : null)
-}
-
-const pickRecord = (record: JsonRecord, key: string): Option.Option<JsonRecord> =>
-  pipe(
-    record[key],
-    Option.fromNullable,
-    Option.filter((value) => isJsonRecord(value))
-  )
-
-const extractCwd = (record: JsonRecord): Option.Option<string> =>
-  pipe(
-    pickString(record, "cwd"),
-    Option.orElse(() =>
-      pipe(
-        pickRecord(record, "payload"),
-        Option.flatMap((payload) => pickString(payload, "cwd"))
-      )
-    )
-  )
-
-const toMetadata = (value: JsonValue): RecordMetadata => {
-  if (!isJsonRecord(value)) {
-    return { cwd: Option.none() }
-  }
-
-  return {
-    cwd: extractCwd(value)
-  }
-}
-
-const cwdMatches = (metadata: RecordMetadata, locator: ProjectLocator): boolean =>
-  Option.exists(metadata.cwd, (cwdValue) => locator.isWithinRoot(cwdValue))
-
-const metadataMatches = (
-  metadata: RecordMetadata,
-  locator: ProjectLocator
-): boolean => cwdMatches(metadata, locator)
-
-/**
- * Builds a locator for matching project-scoped metadata.
- *
- * @param normalizedCwd - Pre-normalized cwd of the project root.
- * @param isWithinRoot - Pure predicate for checking candidate cwd membership.
- * @returns Locator values for project comparisons.
- *
- * @pure true
- * @invariant normalizedCwd is absolute and stable for equal inputs
- * @complexity O(1) time / O(1) space
- */
-// CHANGE: bundle normalized root and pure membership predicate in a locator
-// WHY: keep matching invariants in CORE and leave path normalization in SHELL
-// QUOTE(TZ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall c: locator(c) -> membership(c)
-// PURITY: CORE
-// EFFECT: n/a
-// INVARIANT: normalizedCwd is absolute and stable for equal inputs
-// COMPLEXITY: O(1)/O(1)
-export const buildProjectLocator = (
-  normalizedCwd: string,
-  isWithinRoot: (candidate: string) => boolean
-): ProjectLocator => ({
-  normalizedCwd,
-  isWithinRoot
-})
-
-/**
- * Checks whether a parsed JSON value contains project metadata.
- *
- * @param value - Parsed JSON value from a .jsonl line.
- * @param locator - Normalized project locator.
- * @returns True when cwd matches the project root.
- *
- * @pure true
- * @invariant valueMatchesProject implies metadataMatches for extracted metadata
- * @complexity O(k) where k = number of metadata fields read
- */
-// CHANGE: restrict project matching to cwd-only semantics
-// WHY: align with project-local path matching requirement
-// QUOTE(TZ): "каждая функция — теорема"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall v: JsonValue -> matches(v, locator) <-> metadataMatches(v)
-// PURITY: CORE
-// EFFECT: n/a
-// INVARIANT: metadataMatches uses cwd evidence only
-// COMPLEXITY: O(k)/O(1)
-export const valueMatchesProject = (
-  value: JsonValue,
-  locator: ProjectLocator
-): boolean => metadataMatches(toMetadata(value), locator)

package/src/shell/cli.ts

@@ -1,75 +0,0 @@
-import { Effect } from "effect"
-
-import { RuntimeEnv } from "./services/runtime-env.js"
-import type { SyncOptions } from "./sync/types.js"
-
-type CliKey = Exclude<keyof SyncOptions, "cwd">
-
-const flagMap = new Map<string, CliKey>([
-  ["--project-root", "projectRoot"],
-  ["-r", "projectRoot"],
-  ["--source", "sourceDir"],
-  ["-s", "sourceDir"],
-  ["--dest", "destinationDir"],
-  ["-d", "destinationDir"],
-  ["--project-url", "repositoryUrlOverride"],
-  ["--project-name", "repositoryUrlOverride"],
-  ["--meta-root", "metaRoot"],
-  ["--qwen-source", "qwenSourceDir"],
-  ["--claude-projects", "claudeProjectsRoot"]
-])
-
-const parseArgs = (args: ReadonlyArray<string>, cwd: string): SyncOptions => {
-  let result: SyncOptions = { cwd }
-
-  let index = 0
-  while (index < args.length) {
-    const arg = args[index]
-    if (arg === undefined) {
-      index += 1
-      continue
-    }
-    const key = flagMap.get(arg)
-    if (key === undefined) {
-      index += 1
-      continue
-    }
-
-    const value = args[index + 1]
-    if (value !== undefined) {
-      result = { ...result, [key]: value }
-      index += 2
-      continue
-    }
-    index += 1
-  }
-
-  return result
-}
-
-/**
- * Reads CLI arguments and builds SyncOptions.
- *
- * @returns Effect with resolved SyncOptions.
- *
- * @pure false - reads process argv/cwd via RuntimeEnv
- * @effect RuntimeEnv
- * @invariant options.cwd is always defined; projectRoot overrides cwd for matching
- * @complexity O(n) where n = |args|
- */
-// CHANGE: parse CLI flags with optional project root override
-// WHY: allow matching against repo root while running from subpackages
-// QUOTE(TZ): "передай root-path на основную папку"
-// REF: user-2026-01-19-project-root
-// SOURCE: n/a
-// FORMAT THEOREM: forall a: parse(a) -> SyncOptions
-// PURITY: SHELL
-// EFFECT: Effect<SyncOptions, never, RuntimeEnv>
-// INVARIANT: unknown flags are ignored
-// COMPLEXITY: O(n)/O(1)
-export const readSyncOptions = Effect.gen(function*(_) {
-  const env = yield* _(RuntimeEnv)
-  const argv = yield* _(env.argv)
-  const cwd = yield* _(env.cwd)
-  return parseArgs(argv.slice(2), cwd)
-})

package/src/shell/services/crypto.ts

@@ -1,50 +0,0 @@
-import { Context, Effect, Layer, pipe } from "effect"
-
-export class CryptoService extends Context.Tag("CryptoService")<
-  CryptoService,
-  {
-    readonly sha256: (value: string) => Effect.Effect<string, CryptoError>
-  }
->() {}
-
-export interface CryptoError {
-  readonly _tag: "CryptoError"
-  readonly reason: string
-}
-
-const cryptoError = (reason: string): CryptoError => ({
-  _tag: "CryptoError",
-  reason
-})
-
-const toHex = (buffer: ArrayBuffer): string =>
-  [...new Uint8Array(buffer)]
-    .map((byte) => byte.toString(16).padStart(2, "0"))
-    .join("")
-
-const digestSha256 = (value: string): Effect.Effect<string, CryptoError> =>
-  pipe(
-    Effect.tryPromise({
-      try: () => {
-        const crypto = globalThis.crypto
-        const bytes = new TextEncoder().encode(value)
-        return crypto.subtle.digest("SHA-256", bytes)
-      },
-      catch: (error) => cryptoError(error instanceof Error ? error.message : "Crypto digest failed")
-    }),
-    Effect.map((buffer) => toHex(buffer))
-  )
-
-// CHANGE: isolate hashing behind a service for deterministic testing
-// WHY: avoid direct crypto usage in shell logic
-// QUOTE(TZ): "Внешние зависимости: только через типизированные интерфейсы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall s: sha256(s) -> hex(s)
-// PURITY: SHELL
-// EFFECT: Effect<CryptoService, never, never>
-// INVARIANT: sha256 output length = 64
-// COMPLEXITY: O(n)/O(1)
-export const CryptoServiceLive = Layer.succeed(CryptoService, {
-  sha256: (value) => digestSha256(value)
-})

package/src/shell/services/file-system.ts

@@ -1,142 +0,0 @@
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
-import { Context, Effect, Layer, pipe } from "effect"
-
-import { type SyncError, syncError } from "../sync/types.js"
-
-export type DirectoryEntryKind = "file" | "directory" | "other"
-
-export interface DirectoryEntry {
-  readonly name: string
-  readonly path: string
-  readonly kind: DirectoryEntryKind
-}
-
-export class FileSystemService extends Context.Tag("FileSystemService")<
-  FileSystemService,
-  {
-    readonly readFileString: (pathValue: string) => Effect.Effect<string, SyncError>
-    readonly readDirectory: (
-      pathValue: string
-    ) => Effect.Effect<ReadonlyArray<DirectoryEntry>, SyncError>
-    readonly makeDirectory: (pathValue: string) => Effect.Effect<void, SyncError>
-    readonly copyFile: (
-      sourcePath: string,
-      destinationPath: string
-    ) => Effect.Effect<void, SyncError>
-    readonly exists: (pathValue: string) => Effect.Effect<boolean, SyncError>
-  }
->() {}
-
-const forEach = Effect.forEach
-
-const resolveEntryPath = (
-  path: Path.Path,
-  root: string,
-  entry: string
-): string => (path.isAbsolute(entry) ? entry : path.join(root, entry))
-
-const entryKindFromInfo = (
-  info: FileSystem.File.Info
-): DirectoryEntryKind => {
-  if (info.type === "Directory") {
-    return "directory"
-  }
-  if (info.type === "File") {
-    return "file"
-  }
-  return "other"
-}
-
-const toDirectoryEntry = (
-  path: Path.Path,
-  entryPath: string,
-  info: FileSystem.File.Info
-): DirectoryEntry => ({
-  name: path.basename(entryPath),
-  path: entryPath,
-  kind: entryKindFromInfo(info)
-})
-
-const readEntry = (
-  fs: FileSystem.FileSystem,
-  path: Path.Path,
-  entryPath: string
-): Effect.Effect<DirectoryEntry, SyncError> =>
-  pipe(
-    fs.stat(entryPath),
-    Effect.map((info) => toDirectoryEntry(path, entryPath, info)),
-    Effect.mapError(() => syncError(entryPath, "Cannot read directory entry"))
-  )
-
-const resolveEntry = (
-  fs: FileSystem.FileSystem,
-  path: Path.Path,
-  root: string,
-  entry: string
-): Effect.Effect<DirectoryEntry, SyncError> => {
-  const entryPath = resolveEntryPath(path, root, entry)
-  return readEntry(fs, path, entryPath)
-}
-
-// CHANGE: wrap filesystem access behind a service for typed errors and testing
-// WHY: enforce shell boundary and avoid raw fs usage in logic
-// QUOTE(TZ): "Внешние зависимости: только через типизированные интерфейсы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall p: exists(p) -> readable(p)
-// PURITY: SHELL
-// EFFECT: Effect<FileSystemService, SyncError, never>
-// INVARIANT: readDirectory returns absolute entry paths
-// COMPLEXITY: O(n)/O(n)
-export const FileSystemLive = Layer.effect(
-  FileSystemService,
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystem.FileSystem)
-    const path = yield* _(Path.Path)
-
-    const readFileString = (pathValue: string): Effect.Effect<string, SyncError> =>
-      pipe(
-        fs.readFileString(pathValue, "utf8"),
-        Effect.mapError(() => syncError(pathValue, "Cannot read file"))
-      )
-
-    const readDirectory = (
-      pathValue: string
-    ): Effect.Effect<ReadonlyArray<DirectoryEntry>, SyncError> =>
-      pipe(
-        fs.readDirectory(pathValue),
-        Effect.mapError(() => syncError(pathValue, "Cannot read directory")),
-        Effect.flatMap((entries) => forEach(entries, (entry) => resolveEntry(fs, path, pathValue, entry)))
-      )
-
-    const makeDirectory = (pathValue: string): Effect.Effect<void, SyncError> =>
-      pipe(
-        fs.makeDirectory(pathValue, { recursive: true }),
-        Effect.mapError(() => syncError(pathValue, "Cannot create destination directory structure"))
-      )
-
-    const copyFile = (
-      sourcePath: string,
-      destinationPath: string
-    ): Effect.Effect<void, SyncError> =>
-      pipe(
-        fs.copyFile(sourcePath, destinationPath),
-        Effect.mapError(() => syncError(sourcePath, "Cannot copy file into destination"))
-      )
-
-    const exists = (pathValue: string): Effect.Effect<boolean, SyncError> =>
-      pipe(
-        fs.exists(pathValue),
-        Effect.mapError(() => syncError(pathValue, "Cannot check path existence"))
-      )
-
-    return {
-      readFileString,
-      readDirectory,
-      makeDirectory,
-      copyFile,
-      exists
-    }
-  })
-)