@prover-coder-ai/eslint-plugin-suggest-members 0.0.0

package/src/shell/validation/member-validation-effect.ts

@@ -0,0 +1,307 @@
+// CHANGE: member access validation (Effect)
+// WHY: combine CORE predicates with TS services
+// QUOTE(TZ): n/a
+// REF: AGENTS.md CORE↔SHELL
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: Effect<MemberValidationResult, TypeScriptServiceError, TypeScriptCompilerServiceTag>
+// INVARIANT: Valid | InvalidMember
+// COMPLEXITY: O(n log n)/O(n)
+import { Effect, Match, pipe } from "effect"
+import * as ts from "typescript"
+
+import type { MemberValidationResult } from "../../core/index.js"
+import {
+  extractPropertyName,
+  findSimilarCandidatesEffect,
+  formatMemberMessage,
+  makeInvalidMemberResult,
+  makeValidResult,
+  shouldSkipMemberExpression
+} from "../../core/index.js"
+import type { SuggestionWithScore } from "../../core/types/domain.js"
+import type { BaseESLintNode } from "../../core/types/eslint-nodes.js"
+import type { TypeScriptServiceError } from "../effects/errors.js"
+import { type TypeScriptCompilerService, TypeScriptCompilerServiceTag } from "../services/typescript-compiler.js"
+import { ignoreErrorToUndefined } from "../shared/effect-utils.js"
+import { enrichSuggestionsWithSymbolMapEffect } from "./suggestion-signatures.js"
+
+type MemberMetadataService = Pick<
+  TypeScriptCompilerService,
+  "getTypeName" | "getPropertiesOfType"
+>
+
+type MemberPropertyService =
+  & MemberMetadataService
+  & Pick<TypeScriptCompilerService, "getTypeAtLocation">
+
+type MemberContextualService =
+  & MemberMetadataService
+  & Pick<TypeScriptCompilerService, "getContextualType">
+
+type MemberSignatureService =
+  & MemberMetadataService
+  & Pick<TypeScriptCompilerService, "getSymbolTypeSignature">
+
+type MemberNodeService = MemberPropertyService & MemberSignatureService
+
+interface PropertyMetadata {
+  readonly names: ReadonlyArray<string>
+  readonly symbols: ReadonlyMap<string, ts.Symbol>
+  readonly typeName?: string
+}
+
+const collectUnionPropertiesEffect = (
+  objectType: ts.Type,
+  tsService: MemberMetadataService
+): Effect.Effect<ReadonlyArray<ts.Symbol>, TypeScriptServiceError> =>
+  Effect.gen(function*(_) {
+    if (!objectType.isUnion()) {
+      return yield* _(tsService.getPropertiesOfType(objectType))
+    }
+
+    const emptySymbols: ReadonlyArray<ts.Symbol> = []
+    const properties: Array<ts.Symbol> = []
+    for (const part of objectType.types) {
+      const partProps = yield* _(
+        pipe(
+          tsService.getPropertiesOfType(part),
+          Effect.matchEffect({
+            onFailure: () => Effect.succeed(emptySymbols),
+            onSuccess: (value) => Effect.succeed(value)
+          })
+        )
+      )
+      for (const prop of partProps) {
+        properties.push(prop)
+      }
+    }
+
+    return properties
+  })
+
+const collectPropertyMetadataForType = (
+  objectType: ts.Type,
+  tsNode: ts.Node,
+  tsService: MemberMetadataService
+): Effect.Effect<PropertyMetadata, TypeScriptServiceError> =>
+  Effect.gen(function*(_) {
+    const typeName = yield* _(
+      ignoreErrorToUndefined(tsService.getTypeName(objectType, tsNode))
+    )
+    const properties = yield* _(collectUnionPropertiesEffect(objectType, tsService))
+
+    const names: Array<string> = []
+    const symbols = new Map<string, ts.Symbol>()
+    for (const symbol of properties) {
+      const name = symbol.getName()
+      if (!symbols.has(name)) {
+        names.push(name)
+        symbols.set(name, symbol)
+      }
+    }
+
+    return typeName && typeName.length > 0
+      ? { names, symbols, typeName }
+      : { names, symbols }
+  })
+
+const collectPropertyMetadata = (
+  tsNode: ts.Node,
+  tsService: MemberPropertyService
+): Effect.Effect<PropertyMetadata, TypeScriptServiceError> =>
+  pipe(
+    tsService.getTypeAtLocation(tsNode),
+    Effect.flatMap((objectType) => collectPropertyMetadataForType(objectType, tsNode, tsService))
+  )
+
+const enrichMemberSuggestionsEffect = (
+  suggestions: ReadonlyArray<SuggestionWithScore>,
+  metadata: PropertyMetadata,
+  tsNode: ts.Node | undefined,
+  tsService: MemberSignatureService
+): Effect.Effect<ReadonlyArray<SuggestionWithScore>, TypeScriptServiceError> =>
+  enrichSuggestionsWithSymbolMapEffect(
+    suggestions,
+    metadata.symbols,
+    tsNode,
+    tsService.getSymbolTypeSignature
+  )
+
+const buildMemberValidationEffectWithMetadata = (
+  propertyName: string,
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Node,
+  tsService: MemberSignatureService,
+  metadata: PropertyMetadata
+): Effect.Effect<MemberValidationResult, TypeScriptServiceError> =>
+  metadata.names.includes(propertyName)
+    ? Effect.succeed(makeValidResult())
+    : pipe(
+      findSimilarCandidatesEffect(propertyName, metadata.names),
+      Effect.flatMap((suggestions) =>
+        suggestions.length === 0
+          ? Effect.succeed(makeValidResult())
+          : pipe(
+            enrichMemberSuggestionsEffect(
+              suggestions,
+              metadata,
+              tsNode,
+              tsService
+            ),
+            Effect.map((enriched) => makeInvalidMemberResult(propertyName, enriched, esTreeNode, metadata.typeName))
+          )
+      )
+    )
+
+const buildMemberValidationEffect = (
+  propertyName: string,
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Node,
+  tsService: MemberNodeService
+): Effect.Effect<MemberValidationResult, TypeScriptServiceError> =>
+  pipe(
+    collectPropertyMetadata(tsNode, tsService),
+    Effect.flatMap((metadata) =>
+      buildMemberValidationEffectWithMetadata(
+        propertyName,
+        esTreeNode,
+        tsNode,
+        tsService,
+        metadata
+      )
+    )
+  )
+
+const buildMemberValidationEffectFromContextualType = (
+  propertyName: string,
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Expression,
+  tsService: MemberContextualService & MemberSignatureService
+): Effect.Effect<MemberValidationResult, TypeScriptServiceError> =>
+  pipe(
+    tsService.getContextualType(tsNode),
+    Effect.flatMap((contextualType) =>
+      contextualType
+        ? pipe(
+          collectPropertyMetadataForType(contextualType, tsNode, tsService),
+          Effect.flatMap((metadata) =>
+            buildMemberValidationEffectWithMetadata(
+              propertyName,
+              esTreeNode,
+              tsNode,
+              tsService,
+              metadata
+            )
+          )
+        )
+        : Effect.succeed(makeValidResult())
+    )
+  )
+
+interface MemberValidationParams {
+  readonly propertyName: string
+  readonly esTreeNode: BaseESLintNode
+  readonly tsNode: ts.Node
+  readonly skipValidation: boolean
+}
+
+const validateMemberPropertyNameEffectBase = (
+  params: MemberValidationParams
+): Effect.Effect<
+  MemberValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> =>
+  pipe(
+    Effect.gen(function*(_) {
+      if (params.skipValidation) {
+        return makeValidResult()
+      }
+
+      if (params.propertyName.length === 0) {
+        return makeValidResult()
+      }
+
+      const tsService = yield* _(TypeScriptCompilerServiceTag)
+      return yield* _(
+        buildMemberValidationEffect(
+          params.propertyName,
+          params.esTreeNode,
+          params.tsNode,
+          tsService
+        )
+      )
+    })
+  )
+
+export const validateMemberAccessEffectWithNodes = (
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Node
+): Effect.Effect<
+  MemberValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> =>
+  validateMemberPropertyNameEffectBase({
+    propertyName: extractPropertyName(esTreeNode),
+    esTreeNode,
+    tsNode,
+    skipValidation: shouldSkipMemberExpression(esTreeNode)
+  })
+
+export const validateMemberPropertyNameEffect = (
+  propertyName: string,
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Node
+): Effect.Effect<
+  MemberValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> =>
+  validateMemberPropertyNameEffectBase({
+    propertyName,
+    esTreeNode,
+    tsNode,
+    skipValidation: false
+  })
+
+export const validateObjectLiteralPropertyNameEffect = (
+  propertyName: string,
+  esTreeNode: BaseESLintNode,
+  tsNode: ts.Node
+): Effect.Effect<
+  MemberValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> =>
+  pipe(
+    Effect.gen(function*(_) {
+      if (propertyName.length === 0) {
+        return makeValidResult()
+      }
+
+      const tsService = yield* _(TypeScriptCompilerServiceTag)
+      if (!ts.isExpression(tsNode)) {
+        return makeValidResult()
+      }
+      return yield* _(
+        buildMemberValidationEffectFromContextualType(
+          propertyName,
+          esTreeNode,
+          tsNode,
+          tsService
+        )
+      )
+    })
+  )
+
+export const formatMemberValidationMessage = (
+  result: MemberValidationResult
+): string =>
+  Match.value(result).pipe(
+    Match.when({ _tag: "Valid" }, () => ""),
+    Match.when({ _tag: "InvalidMember" }, (invalid) =>
+      formatMemberMessage(invalid.propertyName, invalid.typeName, invalid.suggestions)),
+    Match.exhaustive
+  )

package/src/shell/validation/missing-name-validation-base.ts

@@ -0,0 +1,153 @@
+// CHANGE: shared missing-name validation base
+// WHY: reuse core logic between missing-name and local-export validation
+// QUOTE(TZ): n/a
+// REF: AGENTS.md CORE↔SHELL
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: Effect<MissingNameValidationResult, TypeScriptServiceError, TypeScriptCompilerServiceTag>
+// INVARIANT: Valid | MissingName
+// COMPLEXITY: O(n log n)/O(n)
+import { Effect, Match, pipe } from "effect"
+import type * as ts from "typescript"
+
+import type { TSESTree } from "@typescript-eslint/utils"
+import type { MissingNameValidationResult } from "../../core/index.js"
+import {
+  findSimilarCandidatesEffect,
+  formatMissingNameMessage,
+  isValidCandidate,
+  makeMissingNameResult,
+  makeValidMissingNameResult,
+  shouldSkipIdentifier
+} from "../../core/index.js"
+import type { SuggestionWithScore } from "../../core/types/domain.js"
+import type { TypeScriptServiceError } from "../effects/errors.js"
+import { type TypeScriptCompilerService, TypeScriptCompilerServiceTag } from "../services/typescript-compiler.js"
+import { enrichSuggestionsWithSymbolMapEffect } from "./suggestion-signatures.js"
+
+type MissingNameService = Pick<
+  TypeScriptCompilerService,
+  "getSymbolsInScope" | "getSymbolTypeSignature"
+>
+
+interface ScopeMetadata {
+  readonly names: ReadonlyArray<string>
+  readonly symbols: ReadonlyMap<string, ts.Symbol>
+}
+
+export interface MissingNameValidationConfig {
+  readonly symbolFlags: ts.SymbolFlags
+  readonly skipWhenNoSuggestions: boolean
+}
+
+const collectScopeMetadata = (
+  tsNode: ts.Node,
+  tsService: MissingNameService,
+  symbolFlags: ts.SymbolFlags
+): Effect.Effect<ScopeMetadata, TypeScriptServiceError> =>
+  Effect.gen(function*(_) {
+    const symbols = yield* _(
+      tsService.getSymbolsInScope(tsNode, symbolFlags)
+    )
+
+    const names: Array<string> = []
+    const map = new Map<string, ts.Symbol>()
+    for (const symbol of symbols) {
+      const name = symbol.getName()
+      if (!isValidCandidate(name)) continue
+      names.push(name)
+      map.set(name, symbol)
+    }
+
+    return { names, symbols: map }
+  })
+
+const enrichMissingNameSuggestionsEffect = (
+  suggestions: ReadonlyArray<SuggestionWithScore>,
+  metadata: ScopeMetadata,
+  tsNode: ts.Node,
+  tsService: MissingNameService
+): Effect.Effect<ReadonlyArray<SuggestionWithScore>, TypeScriptServiceError> =>
+  enrichSuggestionsWithSymbolMapEffect(
+    suggestions,
+    metadata.symbols,
+    tsNode,
+    tsService.getSymbolTypeSignature
+  )
+
+interface BuildMissingNameResultParams {
+  readonly name: string
+  readonly node: TSESTree.Identifier
+  readonly tsNode: ts.Node
+  readonly tsService: MissingNameService
+  readonly metadata: ScopeMetadata
+  readonly config: MissingNameValidationConfig
+}
+
+const buildMissingNameResultEffect = (
+  params: BuildMissingNameResultParams
+): Effect.Effect<MissingNameValidationResult, TypeScriptServiceError> => {
+  const { config, metadata, name, node, tsNode, tsService } = params
+  return (
+    pipe(
+      findSimilarCandidatesEffect(name, metadata.names),
+      Effect.flatMap((suggestions) =>
+        config.skipWhenNoSuggestions && suggestions.length === 0
+          ? Effect.succeed(makeValidMissingNameResult())
+          : pipe(
+            enrichMissingNameSuggestionsEffect(suggestions, metadata, tsNode, tsService),
+            Effect.map((enriched) => makeMissingNameResult(name, enriched, node))
+          )
+      )
+    )
+  )
+}
+
+export const validateMissingNameIdentifierEffectBase = (
+  identifier: TSESTree.Identifier,
+  tsNode: ts.Node,
+  config: MissingNameValidationConfig
+): Effect.Effect<
+  MissingNameValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> =>
+  pipe(
+    Effect.gen(function*(_) {
+      if (shouldSkipIdentifier(identifier.name)) {
+        return makeValidMissingNameResult()
+      }
+
+      const tsService = yield* _(TypeScriptCompilerServiceTag)
+      const metadata = yield* _(
+        collectScopeMetadata(tsNode, tsService, config.symbolFlags)
+      )
+
+      if (metadata.names.includes(identifier.name)) {
+        return makeValidMissingNameResult()
+      }
+
+      return yield* _(
+        buildMissingNameResultEffect({
+          name: identifier.name,
+          node: identifier,
+          tsNode,
+          tsService,
+          metadata,
+          config
+        })
+      )
+    })
+  )
+
+export const formatMissingNameValidationMessage = (
+  result: MissingNameValidationResult
+): string =>
+  Match.value(result).pipe(
+    Match.when({ _tag: "Valid" }, () => ""),
+    Match.when(
+      { _tag: "MissingName" },
+      (missing) => formatMissingNameMessage(missing.name, missing.suggestions)
+    ),
+    Match.exhaustive
+  )

package/src/shell/validation/missing-name-validation-effect.ts

@@ -0,0 +1,10 @@
+// CHANGE: missing name validation (Effect)
+// WHY: re-export shared validator for unresolved names
+// QUOTE(TZ): n/a
+// REF: AGENTS.md CORE↔SHELL
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: n/a
+// INVARIANT: export-only module
+// COMPLEXITY: O(1)/O(1)
+export { formatMissingNameValidationMessage, validateMissingNameIdentifierEffect } from "./missing-name-validators.js"

package/src/shell/validation/missing-name-validators.ts

@@ -0,0 +1,52 @@
+// CHANGE: missing name validators
+// WHY: share configuration for missing-name and local-export checks
+// QUOTE(TZ): n/a
+// REF: AGENTS.md CORE↔SHELL
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: Effect<MissingNameValidationResult, TypeScriptServiceError, TypeScriptCompilerServiceTag>
+// INVARIANT: Valid | MissingName
+// COMPLEXITY: O(n log n)/O(n)
+import type { Effect } from "effect"
+import * as ts from "typescript"
+
+import type { TSESTree } from "@typescript-eslint/utils"
+import type { MissingNameValidationResult } from "../../core/index.js"
+import type { TypeScriptServiceError } from "../effects/errors.js"
+import type { TypeScriptCompilerServiceTag } from "../services/typescript-compiler.js"
+import {
+  type MissingNameValidationConfig,
+  validateMissingNameIdentifierEffectBase
+} from "./missing-name-validation-base.js"
+
+const missingNameConfig: MissingNameValidationConfig = {
+  symbolFlags: ts.SymbolFlags.Value | ts.SymbolFlags.Alias,
+  skipWhenNoSuggestions: true
+}
+
+const localExportConfig: MissingNameValidationConfig = {
+  symbolFlags: ts.SymbolFlags.Value |
+    ts.SymbolFlags.Type |
+    ts.SymbolFlags.Namespace |
+    ts.SymbolFlags.Module,
+  skipWhenNoSuggestions: false
+}
+
+const createMissingNameValidator = (config: MissingNameValidationConfig) =>
+(
+  identifier: TSESTree.Identifier,
+  tsNode: ts.Node
+): Effect.Effect<
+  MissingNameValidationResult,
+  TypeScriptServiceError,
+  TypeScriptCompilerServiceTag
+> => validateMissingNameIdentifierEffectBase(identifier, tsNode, config)
+
+export const validateMissingNameIdentifierEffect = createMissingNameValidator(missingNameConfig)
+
+export const validateLocalExportIdentifierEffect = createMissingNameValidator(localExportConfig)
+
+export {
+  formatMissingNameValidationMessage,
+  formatMissingNameValidationMessage as formatLocalExportValidationMessage
+} from "./missing-name-validation-base.js"

package/src/shell/validation/module-path-index.ts

@@ -0,0 +1,144 @@
+// CHANGE: module path index from TypeScript program
+// WHY: allow sync module-path validation without direct filesystem access
+// QUOTE(TZ): n/a
+// REF: AGENTS.md CORE↔SHELL
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: n/a
+// INVARIANT: index contains only supported file extensions
+// COMPLEXITY: O(n)/O(n)
+import * as S from "@effect/schema/Schema"
+import * as Either from "effect/Either"
+import * as ts from "typescript"
+
+import { SUPPORTED_EXTENSIONS } from "../../core/validation/candidates.js"
+
+export interface ModulePathIndex {
+  readonly localFiles: ReadonlyArray<string>
+  readonly localFileSet: ReadonlySet<string>
+  readonly packageNames: ReadonlyArray<string>
+  readonly packageNameSet: ReadonlySet<string>
+}
+
+const normalizePath = (value: string): string => value.replaceAll("\\", "/")
+
+const isSupportedFile = (filePath: string): boolean => SUPPORTED_EXTENSIONS.some((ext) => filePath.endsWith(ext))
+
+const PackageJsonSchema = S.Struct({
+  dependencies: S.Record({ key: S.String, value: S.String }),
+  devDependencies: S.Record({ key: S.String, value: S.String }),
+  peerDependencies: S.Record({ key: S.String, value: S.String }),
+  optionalDependencies: S.Record({ key: S.String, value: S.String })
+}).pipe(S.partial)
+
+type PackageJson = S.Schema.Type<typeof PackageJsonSchema>
+
+const decodePackageJson = S.decodeUnknownEither(S.parseJson(PackageJsonSchema))
+
+const extractDependencyKeys = (
+  value: Readonly<Record<string, string>> | undefined
+): ReadonlyArray<string> => (value ? Object.keys(value) : [])
+
+const mergeUnique = (
+  chunks: ReadonlyArray<ReadonlyArray<string>>
+): ReadonlyArray<string> => {
+  const unique = new Set<string>()
+  for (const chunk of chunks) {
+    for (const name of chunk) {
+      if (name.length > 0) {
+        unique.add(name)
+      }
+    }
+  }
+  return [...unique]
+}
+
+const extractPackageNames = (value: PackageJson): ReadonlyArray<string> => {
+  const sections: ReadonlyArray<keyof PackageJson> = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]
+  const chunks = sections.map((section) => extractDependencyKeys(value[section]))
+  return mergeUnique(chunks)
+}
+
+const parsePackageJson = (content: string): PackageJson | null =>
+  Either.match(decodePackageJson(content), {
+    onLeft: () => null,
+    onRight: (value) => value
+  })
+
+const dirname = (value: string): string => {
+  const normalized = normalizePath(value)
+  const lastSlash = normalized.lastIndexOf("/")
+  if (lastSlash <= 0) return normalized
+  return normalized.slice(0, lastSlash)
+}
+
+const joinPath = (...segments: ReadonlyArray<string>): string => normalizePath(segments.join("/"))
+
+const findNearestPackageJson = (startDir: string): string | null => {
+  let currentDir = normalizePath(startDir)
+  let parentDir = dirname(currentDir)
+
+  while (currentDir !== parentDir) {
+    const candidate = joinPath(currentDir, "package.json")
+    if (ts.sys.fileExists(candidate)) return candidate
+    currentDir = parentDir
+    parentDir = dirname(currentDir)
+  }
+
+  const rootCandidate = joinPath(currentDir, "package.json")
+  return ts.sys.fileExists(rootCandidate) ? rootCandidate : null
+}
+
+const readPackageNamesFromNearest = (
+  startDir: string
+): ReadonlyArray<string> => {
+  const packageJsonPath = findNearestPackageJson(startDir)
+  if (!packageJsonPath) return []
+  const content = ts.sys.readFile(packageJsonPath)
+  if (!content) return []
+  const parsed = parsePackageJson(content)
+  return parsed ? extractPackageNames(parsed) : []
+}
+
+const moduleIndexCache = new WeakMap<ts.Program, ModulePathIndex>()
+
+export const buildModulePathIndex = (program: ts.Program): ModulePathIndex => {
+  const localFiles: Array<string> = []
+  const packageNames = new Set<string>()
+
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue
+    const normalized = normalizePath(sourceFile.fileName)
+    if (normalized.includes("/node_modules/")) continue
+
+    if (isSupportedFile(normalized)) {
+      localFiles.push(normalized)
+    }
+  }
+
+  const packageFromManifest = readPackageNamesFromNearest(program.getCurrentDirectory())
+  for (const name of packageFromManifest) {
+    packageNames.add(name)
+  }
+
+  const uniqueFiles = [...new Set(localFiles)]
+  return {
+    localFiles: uniqueFiles,
+    localFileSet: new Set(uniqueFiles),
+    packageNames: [...packageNames],
+    packageNameSet: new Set(packageNames)
+  }
+}
+
+export const getModulePathIndex = (program: ts.Program): ModulePathIndex => {
+  const cached = moduleIndexCache.get(program)
+  if (cached) return cached
+  const computed = buildModulePathIndex(program)
+  moduleIndexCache.set(program, computed)
+  return computed
+}