@prover-coder-ai/dist-deps-prune 1.0.2

package/src/core/prune.ts

@@ -0,0 +1,138 @@
+import type { DependencyMap, PackageJson } from "./package-json.js"
+import { omitDependencyFields } from "./package-json.js"
+import type { UnusedByKind } from "./types.js"
+
+// CHANGE: implement dependency pruning plan calculation
+// WHY: provide deterministic diff generation and conservative safety mode
+// QUOTE(TZ): "Удалять из dependencies всё, что отсутствует в USED"
+// REF: req-prune-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀d ∈ prunable: d ∉ USED ∧ d ∉ KEEP
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: peerDependencies are never removed
+// COMPLEXITY: O(n) where n = total dependencies
+
+export interface PruneOptions {
+  readonly used: ReadonlySet<string>
+  readonly keep: ReadonlySet<string>
+  readonly pruneDev: boolean
+  readonly pruneOptional: boolean
+  readonly conservative: boolean
+  readonly hasUncertainty: boolean
+}
+
+export interface PrunePlan {
+  readonly unused: UnusedByKind
+  readonly prunable: UnusedByKind
+  readonly keptByRule: ReadonlyArray<string>
+  readonly nextPackageJson: PackageJson
+}
+
+const emptyUnused: UnusedByKind = {
+  dependencies: [],
+  devDependencies: [],
+  optionalDependencies: [],
+  peerDependencies: []
+}
+
+const listKeys = (map: DependencyMap | undefined): ReadonlyArray<string> => map === undefined ? [] : Object.keys(map)
+
+const filterMap = (
+  map: DependencyMap | undefined,
+  remove: ReadonlySet<string>
+): DependencyMap | undefined => {
+  if (map === undefined) {
+    return undefined
+  }
+  const entries = Object.entries(map).filter(([name]) => !remove.has(name))
+  if (entries.length === 0) {
+    return undefined
+  }
+  const result: Record<string, string> = {}
+  for (const [name, version] of entries) {
+    result[name] = version
+  }
+  return result
+}
+
+const computeUnused = (
+  map: DependencyMap | undefined,
+  used: ReadonlySet<string>,
+  keep: ReadonlySet<string>
+): ReadonlyArray<string> => listKeys(map).filter((name) => !used.has(name) && !keep.has(name))
+
+const computeUnusedByKind = (pkg: PackageJson, options: PruneOptions): UnusedByKind => ({
+  dependencies: computeUnused(pkg.dependencies, options.used, options.keep),
+  devDependencies: computeUnused(pkg.devDependencies, options.used, options.keep),
+  optionalDependencies: computeUnused(pkg.optionalDependencies, options.used, options.keep),
+  peerDependencies: computeUnused(pkg.peerDependencies, options.used, options.keep)
+})
+
+const computePrunableByKind = (unused: UnusedByKind, options: PruneOptions): UnusedByKind => {
+  const hasUncertainty = options.conservative && options.hasUncertainty
+  return {
+    ...emptyUnused,
+    dependencies: hasUncertainty ? [] : unused.dependencies,
+    devDependencies: options.pruneDev && !hasUncertainty ? unused.devDependencies : [],
+    optionalDependencies: options.pruneOptional && !hasUncertainty ? unused.optionalDependencies : [],
+    peerDependencies: []
+  }
+}
+
+const computeKeptByRule = (
+  unused: UnusedByKind,
+  prunable: UnusedByKind,
+  options: PruneOptions
+): ReadonlyArray<string> => {
+  const keptExplicit = [...options.keep].filter((name) => !options.used.has(name))
+  return [
+    ...keptExplicit,
+    ...unused.dependencies.filter((name) => !prunable.dependencies.includes(name)),
+    ...unused.devDependencies.filter((name) => !prunable.devDependencies.includes(name)),
+    ...unused.optionalDependencies.filter((name) => !prunable.optionalDependencies.includes(name)),
+    ...unused.peerDependencies
+  ]
+}
+
+const buildNextPackageJson = (pkg: PackageJson, prunable: UnusedByKind): PackageJson => {
+  const removeDependencies = new Set(prunable.dependencies)
+  const removeDev = new Set(prunable.devDependencies)
+  const removeOptional = new Set(prunable.optionalDependencies)
+  const nextDependencies = filterMap(pkg.dependencies, removeDependencies)
+  const nextDevDependencies = filterMap(pkg.devDependencies, removeDev)
+  const nextOptionalDependencies = filterMap(pkg.optionalDependencies, removeOptional)
+  const base = omitDependencyFields(pkg)
+  return {
+    ...base,
+    ...(nextDependencies === undefined ? {} : { dependencies: nextDependencies }),
+    ...(nextDevDependencies === undefined ? {} : { devDependencies: nextDevDependencies }),
+    ...(nextOptionalDependencies === undefined ? {} : { optionalDependencies: nextOptionalDependencies }),
+    ...(pkg.peerDependencies === undefined ? {} : { peerDependencies: pkg.peerDependencies })
+  }
+}
+
+/**
+ * Build the prune plan (analysis + actual removal) for a package.json.
+ *
+ * @param pkg - Parsed package.json.
+ * @param options - Prune options (used set, keep rules, mode flags).
+ * @returns PrunePlan with unused, prunable, and next package.json.
+ *
+ * @pure true
+ * @invariant peerDependencies remain unchanged
+ * @complexity O(n)
+ */
+export const buildPrunePlan = (pkg: PackageJson, options: PruneOptions): PrunePlan => {
+  const unused = computeUnusedByKind(pkg, options)
+  const prunable = computePrunableByKind(unused, options)
+  const keptByRule = computeKeptByRule(unused, prunable, options)
+  const nextPackageJson = buildNextPackageJson(pkg, prunable)
+
+  return {
+    unused,
+    prunable,
+    keptByRule,
+    nextPackageJson
+  }
+}

package/src/core/report.ts

@@ -0,0 +1,145 @@
+import { Match } from "effect"
+import type { PrunePlan } from "./prune.js"
+import type { Report, ScanOutcome, UnusedByKind, Warning } from "./types.js"
+
+// CHANGE: build structured reports and render output formats
+// WHY: keep reporting pure and deterministic across CLI modes
+// QUOTE(TZ): "Отчёт в stdout (человекочитаемый)"
+// REF: req-report-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀r: report(r).used is sorted
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: Report.used is unique and sorted
+// COMPLEXITY: O(n log n)
+
+const compareStrings = (left: string, right: string): number => left.localeCompare(right)
+
+const mergeSorted = (
+  left: ReadonlyArray<string>,
+  right: ReadonlyArray<string>
+): ReadonlyArray<string> => {
+  if (left.length === 0) {
+    return right
+  }
+  if (right.length === 0) {
+    return left
+  }
+  const leftHead = left[0] ?? ""
+  const rightHead = right[0] ?? ""
+  if (compareStrings(leftHead, rightHead) <= 0) {
+    return [leftHead, ...mergeSorted(left.slice(1), right)]
+  }
+  return [rightHead, ...mergeSorted(left, right.slice(1))]
+}
+
+const mergeSort = (values: ReadonlyArray<string>): ReadonlyArray<string> => {
+  if (values.length <= 1) {
+    return [...values]
+  }
+  const mid = Math.floor(values.length / 2)
+  const left = mergeSort(values.slice(0, mid))
+  const right = mergeSort(values.slice(mid))
+  return mergeSorted(left, right)
+}
+
+const sortUnique = (values: ReadonlyArray<string>): ReadonlyArray<string> => mergeSort([...new Set(values)])
+
+const sortUnused = (unused: UnusedByKind): UnusedByKind => ({
+  dependencies: sortUnique(unused.dependencies),
+  devDependencies: sortUnique(unused.devDependencies),
+  optionalDependencies: sortUnique(unused.optionalDependencies),
+  peerDependencies: sortUnique(unused.peerDependencies)
+})
+
+/**
+ * Build a Report object from scan and prune results.
+ *
+ * @param scan - Scan outcome with used set and warnings.
+ * @param plan - Prune plan with unused lists and keptByRule.
+ * @returns Report ready for output.
+ *
+ * @pure true
+ * @invariant report.used is sorted and unique
+ * @complexity O(n log n)
+ */
+export const buildReport = (scan: ScanOutcome, plan: PrunePlan): Report => ({
+  used: sortUnique([...scan.used]),
+  unused: sortUnused(plan.unused),
+  keptByRule: sortUnique(plan.keptByRule),
+  warnings: scan.warnings,
+  stats: scan.stats
+})
+
+const formatWarning = (warning: Warning): string =>
+  Match.value(warning).pipe(
+    Match.when({ type: "dynamic-import" }, (value) => `[dynamic-import] ${value.file}: ${value.expr}`),
+    Match.when({ type: "dynamic-require" }, (value) => `[dynamic-require] ${value.file}: ${value.expr}`),
+    Match.when({ type: "parse-error" }, (value) => `[parse-error] ${value.file}: ${value.error}`),
+    Match.exhaustive
+  )
+
+const formatList = (title: string, values: ReadonlyArray<string>): ReadonlyArray<string> => {
+  if (values.length === 0) {
+    return [`${title}: (none)`]
+  }
+  return [title + ":", ...values.map((value) => `  - ${value}`)]
+}
+
+/**
+ * Render a human-readable report.
+ *
+ * @param report - Report data.
+ * @returns Multi-line string for stdout.
+ *
+ * @pure true
+ * @invariant output lists all required sections
+ * @complexity O(n)
+ */
+export const renderHumanReport = (report: Report): string => {
+  const lines = [
+    ...formatList("USED", report.used),
+    ...formatList("Unused dependencies", report.unused.dependencies),
+    ...formatList("Unused devDependencies", report.unused.devDependencies),
+    ...formatList("Unused optionalDependencies", report.unused.optionalDependencies),
+    ...formatList("Peer dependencies (reported only)", report.unused.peerDependencies)
+  ]
+  const warningLines = report.warnings.length === 0
+    ? ["Warnings: (none)"]
+    : [
+      "Warnings:",
+      ...report.warnings
+        .map((warning) => formatWarning(warning))
+        .map((line) => `  - ${line}`)
+    ]
+  const statsLines = [
+    `Stats: filesScanned=${report.stats.filesScanned}, importsFound=${report.stats.importsFound}`
+  ]
+  return [...lines, ...warningLines, ...statsLines].join("\n")
+}
+
+/**
+ * Render report as JSON text.
+ *
+ * @param report - Report data.
+ * @returns JSON string.
+ *
+ * @pure true
+ * @invariant output matches the JSON schema described in the spec
+ * @complexity O(n)
+ */
+export const renderJsonReport = (report: Report): string =>
+  JSON.stringify(
+    {
+      used: report.used,
+      unused: {
+        dependencies: report.unused.dependencies,
+        devDependencies: report.unused.devDependencies
+      },
+      keptByRule: report.keptByRule,
+      warnings: report.warnings,
+      stats: report.stats
+    },
+    null,
+    2
+  )

package/src/core/types.ts

@@ -0,0 +1,41 @@
+// CHANGE: define core domain types for scan results, warnings, and reports
+// WHY: keep IO-free data structures reusable across CLI modes and tests
+// QUOTE(TZ): "Генерирует отчёт и (по флагу) удаляет неиспользуемые зависимости."
+// REF: req-report-types-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀r ∈ Report: r.used ⊆ Packages ∧ r.unused.dependencies ⊆ Packages
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: warning.type ∈ {"dynamic-import","dynamic-require","parse-error"}
+// COMPLEXITY: O(1)/O(1)
+
+export type Warning =
+  | { readonly type: "dynamic-import"; readonly file: string; readonly expr: string }
+  | { readonly type: "dynamic-require"; readonly file: string; readonly expr: string }
+  | { readonly type: "parse-error"; readonly file: string; readonly error: string }
+
+export interface ScanStats {
+  readonly filesScanned: number
+  readonly importsFound: number
+}
+
+export interface ScanOutcome {
+  readonly used: ReadonlySet<string>
+  readonly warnings: ReadonlyArray<Warning>
+  readonly stats: ScanStats
+}
+
+export interface UnusedByKind {
+  readonly dependencies: ReadonlyArray<string>
+  readonly devDependencies: ReadonlyArray<string>
+  readonly optionalDependencies: ReadonlyArray<string>
+  readonly peerDependencies: ReadonlyArray<string>
+}
+
+export interface Report {
+  readonly used: ReadonlyArray<string>
+  readonly unused: UnusedByKind
+  readonly keptByRule: ReadonlyArray<string>
+  readonly warnings: ReadonlyArray<Warning>
+  readonly stats: ScanStats
+}

package/src/shell/builtins.ts

@@ -0,0 +1,32 @@
+import * as Effect from "effect/Effect"
+
+import type { AppError } from "../core/errors.js"
+import { fileError } from "../core/errors.js"
+
+// CHANGE: provide Node builtin module set for filtering
+// WHY: builtins must be excluded from USED dependency detection
+// QUOTE(TZ): "Node builtins: fs, path, url, node:fs и т.д."
+// REF: req-builtins-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀b ∈ builtins: b does not represent an external package
+// PURITY: SHELL
+// EFFECT: Effect<ReadonlySet<string>, AppError, never>
+// INVARIANT: node: prefix is stripped
+// COMPLEXITY: O(n)
+
+export const loadBuiltinModules: Effect.Effect<ReadonlySet<string>, AppError> = Effect.tryPromise({
+  try: () => import("node:module"),
+  catch: (error) => fileError(String(error))
+}).pipe(
+  Effect.map((module) => {
+    const result = new Set<string>()
+    for (const name of module.builtinModules) {
+      if (name.startsWith("node:")) {
+        result.add(name.slice("node:".length))
+      } else {
+        result.add(name)
+      }
+    }
+    return result
+  })
+)

package/src/shell/command.ts

@@ -0,0 +1,114 @@
+import * as Command from "@effect/platform/Command"
+import type { CommandExecutor } from "@effect/platform/CommandExecutor"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import { pipe } from "effect/Function"
+
+import type { AppError } from "../core/errors.js"
+import { fileError } from "../core/errors.js"
+
+// CHANGE: run external command with Effect CommandExecutor
+// WHY: enable release mode with typed exit code handling
+// QUOTE(TZ): "Запускает команду из --command"
+// REF: req-command-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀c: run(c) = code → code ∈ ℕ
+// PURITY: SHELL
+// EFFECT: Effect<number, AppError, CommandExecutor>
+// INVARIANT: stdout/stderr are inherited
+// COMPLEXITY: O(n)
+
+type QuoteState = "\"" | "'" | null
+
+interface ParseStep {
+  readonly current: string
+  readonly quote: QuoteState
+  readonly index: number
+  readonly pushToken: boolean
+}
+
+const consumeQuoted = (
+  input: string,
+  index: number,
+  current: string,
+  quote: QuoteState
+): ParseStep => {
+  const char = input.charAt(index)
+  const nextChar = input.charAt(index + 1)
+  if (quote !== null && char === quote) {
+    return { current, quote: null, index: index + 1, pushToken: false }
+  }
+  if (quote === "\"" && char === "\\" && nextChar.length > 0) {
+    return { current: current + nextChar, quote, index: index + 2, pushToken: false }
+  }
+  return { current: current + char, quote, index: index + 1, pushToken: false }
+}
+
+const consumeUnquoted = (input: string, index: number, current: string): ParseStep => {
+  const char = input.charAt(index)
+  const nextChar = input.charAt(index + 1)
+  if (char === "\"" || char === "'") {
+    return { current, quote: char, index: index + 1, pushToken: false }
+  }
+  if (char.trim().length === 0) {
+    return { current: "", quote: null, index: index + 1, pushToken: current.length > 0 }
+  }
+  if (char === "\\" && nextChar.length > 0) {
+    return { current: current + nextChar, quote: null, index: index + 2, pushToken: false }
+  }
+  return { current: current + char, quote: null, index: index + 1, pushToken: false }
+}
+
+const splitCommandLine = (input: string): Either.Either<Array<string>, AppError> => {
+  let result: Array<string> = []
+  let current = ""
+  let quote: QuoteState = null
+  let index = 0
+  while (index < input.length) {
+    const step: ParseStep = quote
+      ? consumeQuoted(input, index, current, quote)
+      : consumeUnquoted(input, index, current)
+    if (step.pushToken) {
+      result = [...result, current]
+    }
+    current = step.current
+    quote = step.quote
+    index = step.index
+  }
+  if (quote !== null) {
+    return Either.left(fileError("Unterminated quote in --command"))
+  }
+  if (current.length > 0) {
+    result = [...result, current]
+  }
+  return Either.right(result)
+}
+
+export const runCommand = (
+  commandLine: string,
+  cwd: string
+): Effect.Effect<number, AppError, CommandExecutor> =>
+  Effect.gen(function*(_) {
+    const parts = splitCommandLine(commandLine)
+    if (Either.isLeft(parts)) {
+      return yield* _(Effect.fail(parts.left))
+    }
+    if (parts.right.length === 0) {
+      return yield* _(Effect.fail(fileError("Empty --command")))
+    }
+    const [cmd, ...args] = parts.right
+    if (cmd === undefined) {
+      return yield* _(Effect.fail(fileError("Empty --command")))
+    }
+    const command = pipe(
+      Command.make(cmd, ...args),
+      Command.stdin("inherit"),
+      Command.stdout("inherit"),
+      Command.stderr("inherit"),
+      Command.workingDirectory(cwd)
+    )
+    const exitCode = yield* _(
+      Command.exitCode(command).pipe(Effect.mapError((error) => fileError(String(error))))
+    )
+    return Number(exitCode)
+  })

package/src/shell/config-file.ts

@@ -0,0 +1,71 @@
+import type { FileSystem as FileSystemService } from "@effect/platform/FileSystem"
+import { FileSystem } from "@effect/platform/FileSystem"
+import * as S from "@effect/schema/Schema"
+import * as TreeFormatter from "@effect/schema/TreeFormatter"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+
+import type { FileConfig } from "../core/config.js"
+import type { AppError } from "../core/errors.js"
+import { configError, fileError } from "../core/errors.js"
+
+// CHANGE: decode .dist-deps-prune.json with schema validation
+// WHY: keep boundary data typed and reject invalid config early
+// QUOTE(TZ): "поддержать файл .dist-deps-prune.json"
+// REF: req-config-file-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀c: decode(c) = Right(cfg) → cfg fields have correct types
+// PURITY: SHELL
+// EFFECT: Effect<FileConfig | undefined, AppError, FileSystem>
+// INVARIANT: missing config yields undefined
+// COMPLEXITY: O(n)
+
+const RawConfigSchema = S.partial(
+  S.Struct({
+    keep: S.Array(S.String),
+    ignorePatterns: S.Array(S.String),
+    pruneDev: S.Boolean,
+    pruneOptional: S.Boolean,
+    patterns: S.Array(S.String)
+  })
+)
+
+const ConfigSchema = S.parseJson(RawConfigSchema)
+
+const decodeConfig = (raw: string): Effect.Effect<FileConfig, AppError> =>
+  pipe(
+    S.decodeUnknown(ConfigSchema)(raw),
+    Effect.map((config) => ({
+      ...(config.keep === undefined ? {} : { keep: config.keep }),
+      ...(config.ignorePatterns === undefined ? {} : { ignorePatterns: config.ignorePatterns }),
+      ...(config.pruneDev === undefined ? {} : { pruneDev: config.pruneDev }),
+      ...(config.pruneOptional === undefined ? {} : { pruneOptional: config.pruneOptional }),
+      ...(config.patterns === undefined ? {} : { patterns: config.patterns })
+    })),
+    Effect.mapError((error) => configError(TreeFormatter.formatErrorSync(error)))
+  )
+
+export const loadConfigFile = (
+  path: string | undefined,
+  explicit: boolean
+): Effect.Effect<FileConfig | undefined, AppError, FileSystemService> =>
+  Effect.gen(function*(_) {
+    if (path === undefined) {
+      return
+    }
+    const fs = yield* _(FileSystem)
+    const exists = yield* _(
+      fs.exists(path).pipe(Effect.mapError((error) => fileError(String(error))))
+    )
+    if (!exists) {
+      if (explicit) {
+        return yield* _(Effect.fail(fileError(`Config file not found: ${path}`)))
+      }
+      return
+    }
+    const contents = yield* _(
+      fs.readFileString(path).pipe(Effect.mapError((error) => fileError(String(error))))
+    )
+    const decoded = yield* _(decodeConfig(contents))
+    return decoded
+  })

package/src/shell/package-json.ts

@@ -0,0 +1,80 @@
+import type { FileSystem as FileSystemService } from "@effect/platform/FileSystem"
+import { FileSystem } from "@effect/platform/FileSystem"
+import * as Schema from "@effect/schema/Schema"
+import * as TreeFormatter from "@effect/schema/TreeFormatter"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+
+import type { AppError } from "../core/errors.js"
+import { fileError } from "../core/errors.js"
+import type { Json } from "../core/json.js"
+import { decodePackageJson, isJsonObject } from "../core/package-json.js"
+import type { PackageJson } from "../core/package-json.js"
+
+// CHANGE: provide package.json read/write helpers with validation
+// WHY: isolate filesystem IO while keeping typed dependency maps
+// QUOTE(TZ): "package.json текущего пакета"
+// REF: req-pkg-io-1
+// SOURCE: n/a
+// FORMAT THEOREM: ∀p: read(p) = Right(pkg) → pkg.dependencies values are strings
+// PURITY: SHELL
+// EFFECT: Effect<PackageJson, AppError, FileSystem>
+// INVARIANT: JSON is validated before use
+// COMPLEXITY: O(n)
+
+const JsonSchema: Schema.Schema<Json> = Schema.suspend(() =>
+  Schema.Union(
+    Schema.Null,
+    Schema.Boolean,
+    Schema.Number,
+    Schema.String,
+    Schema.Array(JsonSchema),
+    Schema.Record({ key: Schema.String, value: JsonSchema })
+  )
+)
+
+const JsonParseSchema = Schema.parseJson(JsonSchema)
+
+const parseJson = (raw: string): Effect.Effect<Json, AppError> =>
+  pipe(
+    Schema.decodeUnknown(JsonParseSchema)(raw),
+    Effect.mapError((error) => fileError(TreeFormatter.formatErrorSync(error)))
+  )
+
+export const readPackageJsonRaw = (
+  path: string
+): Effect.Effect<string, AppError, FileSystemService> =>
+  Effect.gen(function*(_) {
+    const fs = yield* _(FileSystem)
+    return yield* _(
+      fs.readFileString(path).pipe(Effect.mapError((error) => fileError(String(error))))
+    )
+  })
+
+export const readPackageJson = (
+  path: string
+): Effect.Effect<PackageJson, AppError, FileSystemService> =>
+  Effect.gen(function*(_) {
+    const raw = yield* _(readPackageJsonRaw(path))
+    const parsed = yield* _(parseJson(raw))
+    if (!isJsonObject(parsed)) {
+      return yield* _(Effect.fail(fileError("package.json must be an object")))
+    }
+    const decoded = decodePackageJson(parsed)
+    if (decoded._tag === "Left") {
+      return yield* _(Effect.fail(fileError(decoded.left.message)))
+    }
+    return decoded.right
+  })
+
+export const writePackageJson = (
+  path: string,
+  pkg: PackageJson
+): Effect.Effect<void, AppError, FileSystemService> =>
+  Effect.gen(function*(_) {
+    const fs = yield* _(FileSystem)
+    const payload = JSON.stringify(pkg, null, 2) + "\n"
+    yield* _(
+      fs.writeFileString(path, payload).pipe(Effect.mapError((error) => fileError(String(error))))
+    )
+  })