react-doctor 0.2.2 → 0.2.4

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+import * as Schema from "effect/Schema";
 import fs from "node:fs";
-//#region ../types/dist/index.d.ts
-//#region src/config.d.ts
+import * as Cause from "effect/Cause";
+//#region ../core/dist/index.d.ts
+//#region src/types/config.d.ts
 type FailOnLevel = "error" | "warning" | "none";
 interface ReactDoctorIgnoreOverride {
   files: string[];
@@ -92,7 +94,7 @@ interface ReactDoctorConfig {
   failOn?: FailOnLevel;
   customRulesOnly?: boolean;
   share?: boolean;
-  offline?: boolean;
+  noScore?: boolean;
   /**
    * Redirect react-doctor at a different project directory than the one
    * it was invoked against. Resolved relative to the location of the
@@ -240,8 +242,44 @@ interface ReactDoctorConfig {
    * single category, use `ignore.tags` instead.
    */
   categories?: Record<string, RuleSeverityOverride>;
+  /**
+   * User-defined oxlint plugins to load alongside the built-in
+   * `react-doctor` plugin. Each entry is either:
+   *
+   * - A **relative path** to a JS / TS file (resolved relative to
+   *   the directory of the config file that declared it — NOT the
+   *   CWD), e.g. `"./lint/my-rules.js"`.
+   * - An **npm package name**, e.g. `"react-doctor-plugin-team-conventions"`.
+   *
+   * The module must default-export an oxlint-shaped plugin:
+   * `{ meta: { name: string }, rules: Record<string, HostRule> }`.
+   * Use `defineRule` from `oxlint-plugin-react-doctor` for the
+   * cleanest authoring shape — see CONTRIBUTING.md → "Writing a
+   * custom plugin" for the full template.
+   *
+   * Rules from a user plugin are **opt-in by default**: a rule
+   * doesn't run unless `rules: { "<plugin-name>/<rule>": "warn" | "error" }`
+   * explicitly enables it. (Mirrors how `defaultEnabled: false`
+   * rules behave in the built-in plugin.) Once enabled, the rule
+   * flows through every react-doctor surface (CLI / PR comment /
+   * score / CI gate) the same as a built-in rule.
+   *
+   * ```json
+   * {
+   *   "plugins": [
+   *     "./lint/my-team-rules.js",
+   *     "react-doctor-plugin-shopify-conventions"
+   *   ],
+   *   "rules": {
+   *     "my-team-rules/no-bare-fetch": "error",
+   *     "shopify-conventions/use-polaris-tokens": "warn"
+   *   }
+   * }
+   * ```
+   */
+  plugins?: string[];
 } //#endregion
-//#region src/diagnostic.d.ts
+//#region src/types/diagnostic.d.ts
 interface Diagnostic {
   filePath: string;
   plugin: string;
@@ -256,7 +294,7 @@ interface Diagnostic {
   suppressionHint?: string;
 }
 //#endregion
-//#region src/project-info.d.ts
+//#region src/types/project-info.d.ts
 type Framework = "nextjs" | "vite" | "cra" | "remix" | "gatsby" | "expo" | "react-native" | "tanstack-start" | "unknown";
 interface ProjectInfo {
   rootDirectory: string;
@@ -285,12 +323,12 @@ interface ProjectInfo {
   sourceFileCount: number;
 }
 //#endregion
-//#region src/score.d.ts
+//#region src/types/score.d.ts
 interface ScoreResult {
   score: number;
   label: string;
 } //#endregion
-//#region src/diagnose.d.ts
+//#region src/types/diagnose.d.ts
 interface DiagnoseOptions {
   lint?: boolean;
   /** See `ReactDoctorConfig.deadCode`. Ignored in diff mode. */
@@ -317,9 +355,9 @@ interface DiagnoseResult {
   project: ProjectInfo;
   elapsedMilliseconds: number;
 } //#endregion
-//#region src/handle-error.d.ts
+//#region src/types/handle-error.d.ts
 //#endregion
-//#region src/inspect.d.ts
+//#region src/types/inspect.d.ts
 interface InspectResult {
   diagnostics: Diagnostic[];
   score: ScoreResult | null;
@@ -396,40 +434,158 @@ interface JsonReport {
   elapsedMilliseconds: number;
   error: JsonReportError | null;
 } //#endregion
-//#region src/prompts.d.ts
-//#endregion
-//#region ../project-info/dist/index.d.ts
+//#region src/types/prompts.d.ts
 //#endregion
-//#region src/errors.d.ts
-declare class ReactDoctorError extends Error {
-  readonly name: string;
-  constructor(message: string, options?: ErrorOptions);
-}
-declare class ProjectNotFoundError extends ReactDoctorError {
+//#region src/project-info/errors.d.ts
+/**
+ * Narrow errors raised by the project-discovery helpers
+ * (`discoverProject` / `resolveDiagnoseTarget` / `readPackageJson`).
+ *
+ * These extend `Error` directly — they are NOT the tagged
+ * `ReactDoctorError` from `../errors.js` (that one wraps every
+ * runtime-pipeline failure as a `Schema.TaggedErrorClass` for
+ * `Effect.catchReasons` dispatch). The split is intentional:
+ *
+ * - Discovery happens BEFORE the Effect runtime takes over — at the
+ *   `diagnose()` / CLI entry point — and throws plain JS exceptions
+ *   so callers can `try/catch` without an Effect-layer-aware
+ *   `instanceof` check.
+ * - The Project service (`services/project.ts → translateProjectInfoError`)
+ *   translates each of these into the equivalent tagged-error
+ *   `reason` before re-raising inside the Effect pipeline, so the
+ *   runtime never sees a non-tagged failure.
+ *
+ * If you're inside the Effect runtime, use the tagged
+ * `ReactDoctorError` from `../errors.js` instead.
+ */
+declare class ProjectNotFoundError extends Error {
   readonly name = "ProjectNotFoundError";
   readonly directory: string;
   constructor(directory: string, options?: ErrorOptions);
 }
-declare class NoReactDependencyError extends ReactDoctorError {
+declare class NoReactDependencyError extends Error {
   readonly name = "NoReactDependencyError";
   readonly directory: string;
   constructor(directory: string, options?: ErrorOptions);
 }
-declare class PackageJsonNotFoundError extends ReactDoctorError {
+declare class PackageJsonNotFoundError extends Error {
   readonly name = "PackageJsonNotFoundError";
   readonly directory: string;
   constructor(directory: string, options?: ErrorOptions);
 }
-declare class AmbiguousProjectError extends ReactDoctorError {
+declare class AmbiguousProjectError extends Error {
   readonly name = "AmbiguousProjectError";
   readonly directory: string;
   readonly candidates: readonly string[];
   constructor(directory: string, candidates: readonly string[], options?: ErrorOptions);
 }
-declare const isReactDoctorError: (value: unknown) => value is ReactDoctorError; //#endregion
-//#region src/utils/is-directory.d.ts
+declare const isProjectDiscoveryError: (value: unknown) => value is ProjectNotFoundError | NoReactDependencyError | PackageJsonNotFoundError | AmbiguousProjectError; //#endregion
+//#region src/project-info/utils/is-directory.d.ts
 //#endregion
-//#region ../core/dist/index.d.ts
+//#region src/errors.d.ts
+declare const OxlintUnavailable_base: Schema.Class<OxlintUnavailable, Schema.TaggedStruct<"OxlintUnavailable", {
+  readonly kind: Schema.Literals<readonly ["binary-not-found", "native-binding-missing"]>;
+  readonly detail: Schema.String;
+}>, Cause.YieldableError>;
+declare class OxlintUnavailable extends OxlintUnavailable_base {
+  get message(): string;
+}
+declare const OxlintBatchExceeded_base: Schema.Class<OxlintBatchExceeded, Schema.TaggedStruct<"OxlintBatchExceeded", {
+  readonly kind: Schema.Literals<readonly ["timeout", "output-too-large", "oom", "killed"]>;
+  readonly detail: Schema.String;
+}>, Cause.YieldableError>;
+declare class OxlintBatchExceeded extends OxlintBatchExceeded_base {
+  get message(): string;
+}
+declare const OxlintSpawnFailed_base: Schema.Class<OxlintSpawnFailed, Schema.TaggedStruct<"OxlintSpawnFailed", {
+  readonly cause: Schema.Unknown;
+}>, Cause.YieldableError>;
+declare class OxlintSpawnFailed extends OxlintSpawnFailed_base {
+  get message(): string;
+}
+declare const OxlintOutputUnparseable_base: Schema.Class<OxlintOutputUnparseable, Schema.TaggedStruct<"OxlintOutputUnparseable", {
+  readonly preview: Schema.String;
+}>, Cause.YieldableError>;
+declare class OxlintOutputUnparseable extends OxlintOutputUnparseable_base {
+  get message(): string;
+}
+declare const ConfigParseFailed_base: Schema.Class<ConfigParseFailed, Schema.TaggedStruct<"ConfigParseFailed", {
+  readonly path: Schema.String;
+  readonly cause: Schema.Unknown;
+}>, Cause.YieldableError>;
+declare class ConfigParseFailed extends ConfigParseFailed_base {
+  get message(): string;
+}
+declare const ProjectNotFound_base: Schema.Class<ProjectNotFound, Schema.TaggedStruct<"ProjectNotFound", {
+  readonly directory: Schema.String;
+}>, Cause.YieldableError>;
+declare class ProjectNotFound extends ProjectNotFound_base {
+  get message(): string;
+}
+declare const NoReactDependency_base: Schema.Class<NoReactDependency, Schema.TaggedStruct<"NoReactDependency", {
+  readonly directory: Schema.String;
+}>, Cause.YieldableError>;
+declare class NoReactDependency extends NoReactDependency_base {
+  get message(): string;
+}
+declare const AmbiguousProject_base: Schema.Class<AmbiguousProject, Schema.TaggedStruct<"AmbiguousProject", {
+  readonly directory: Schema.String;
+  readonly candidates: Schema.$Array<Schema.String>;
+}>, Cause.YieldableError>;
+declare class AmbiguousProject extends AmbiguousProject_base {
+  get message(): string;
+}
+declare const DeadCodeAnalysisFailed_base: Schema.Class<DeadCodeAnalysisFailed, Schema.TaggedStruct<"DeadCodeAnalysisFailed", {
+  readonly cause: Schema.Unknown;
+}>, Cause.YieldableError>;
+declare class DeadCodeAnalysisFailed extends DeadCodeAnalysisFailed_base {
+  get message(): string;
+}
+declare const GitInvocationFailed_base: Schema.Class<GitInvocationFailed, Schema.TaggedStruct<"GitInvocationFailed", {
+  readonly args: Schema.$Array<Schema.String>;
+  readonly directory: Schema.String;
+  readonly cause: Schema.Unknown;
+}>, Cause.YieldableError>;
+declare class GitInvocationFailed extends GitInvocationFailed_base {
+  get message(): string;
+}
+declare const GitBaseBranchMissing_base: Schema.Class<GitBaseBranchMissing, Schema.TaggedStruct<"GitBaseBranchMissing", {
+  readonly branch: Schema.String;
+}>, Cause.YieldableError>;
+declare class GitBaseBranchMissing extends GitBaseBranchMissing_base {
+  get message(): string;
+}
+declare const GitBaseBranchInvalid_base: Schema.Class<GitBaseBranchInvalid, Schema.TaggedStruct<"GitBaseBranchInvalid", {
+  readonly detail: Schema.String;
+}>, Cause.YieldableError>;
+declare class GitBaseBranchInvalid extends GitBaseBranchInvalid_base {
+  get message(): string;
+}
+declare const ReactDoctorError_base: Schema.Class<ReactDoctorError, Schema.TaggedStruct<"ReactDoctorError", {
+  readonly reason: Schema.Union<readonly [typeof OxlintUnavailable, typeof OxlintBatchExceeded, typeof OxlintSpawnFailed, typeof OxlintOutputUnparseable, typeof ConfigParseFailed, typeof ProjectNotFound, typeof NoReactDependency, typeof AmbiguousProject, typeof DeadCodeAnalysisFailed, typeof GitInvocationFailed, typeof GitBaseBranchMissing, typeof GitBaseBranchInvalid]>;
+}>, Cause.YieldableError>;
+declare class ReactDoctorError extends ReactDoctorError_base {
+  get message(): string;
+}
+declare const isReactDoctorError: (error: unknown) => error is ReactDoctorError; //#endregion
+//#region src/observability.d.ts
+/**
+ * Opt-in OpenTelemetry layer. The default `Effect.fn(...)` spans
+ * already populate the in-process tracer; this layer plugs an OTLP
+ * HTTP exporter into the runtime when the user opts in via:
+ *
+ *   REACT_DOCTOR_OTLP_ENDPOINT      e.g. https://api.axiom.co
+ *   REACT_DOCTOR_OTLP_AUTH_HEADER   e.g. "Bearer <token>"
+ *
+ * Both env vars are required to enable export — if either is
+ * missing, the layer is a no-op (matches the pattern from
+ * `react-doctor-evals/src/Observability.ts`, where the equivalent
+ * absent-env path returns `Layer.empty`).
+ *
+ * No setup is required for users who don't care about tracing — the
+ * inspect / diagnose orchestrators always run, this layer just
+ * dictates whether the spans they emit get shipped to a backend.
+ */
 //#endregion
 //#region src/build-json-report-error.d.ts
 interface BuildJsonReportErrorInput {
@@ -453,10 +609,22 @@ interface BuildJsonReportInput {
   totalElapsedMilliseconds: number;
 }
 declare const buildJsonReport: (input: BuildJsonReportInput) => JsonReport; //#endregion
-//#region src/calculate-score.d.ts
+//#region src/can-oxlint-extend-config.d.ts
 //#endregion
 //#region src/get-diff-files.d.ts
-declare const getDiffInfo: (directory: string, explicitBaseBranch?: string) => DiffInfo | null;
+/**
+ * Programmatic façade over `Git.diffSelection`. Async because the
+ * Git service runs through Effect's `ChildProcess` (true subprocess
+ * spawn, not `spawnSync`).
+ *
+ * Tagged-reason errors are dispatched via `Effect.catchReasons`
+ * (a v4-native API for narrowing inside a `Schema.TaggedErrorClass`
+ * union without manual `instanceof` checks). The recovered branches
+ * raise plain `Error`s so existing thrown-class consumers continue
+ * to work — anything else (real `GitInvocationFailed`, etc.)
+ * propagates as the tagged `ReactDoctorError` through `Effect.runPromise`.
+ */
+declare const getDiffInfo: (directory: string, explicitBaseBranch?: string) => Promise<DiffInfo | null>;
 declare const filterSourceFiles: (filePaths: string[]) => string[]; //#endregion
 //#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/types.d.ts
 //#endregion
@@ -464,6 +632,10 @@ declare const filterSourceFiles: (filePaths: string[]) => string[]; //#endregion
 declare const summarizeDiagnostics: (diagnostics: Diagnostic[], worstScore?: number | null, worstScoreLabel?: string | null) => JsonReportSummary; //#endregion
 //#region src/validate-config-types.d.ts
 //#endregion
+//#region ../api/dist/index.d.ts
+//#region src/diagnose.d.ts
+declare const diagnose: (directory: string, options?: DiagnoseOptions) => Promise<DiagnoseResult>; //#endregion
+//#endregion
 //#region src/index.d.ts
 declare const clearCaches: () => void;
 interface ToJsonReportOptions {
@@ -472,7 +644,6 @@ interface ToJsonReportOptions {
   mode?: JsonReportMode;
 }
 declare const toJsonReport: (result: DiagnoseResult, options: ToJsonReportOptions) => JsonReport;
-declare const diagnose: (directory: string, options?: DiagnoseOptions) => Promise<DiagnoseResult>;
 //#endregion
-export { AmbiguousProjectError, type DiagnoseOptions, type DiagnoseResult, type Diagnostic, type DiffInfo, type JsonReport, type JsonReportDiffInfo, type JsonReportError, type JsonReportMode, type JsonReportProjectEntry, type JsonReportSummary, NoReactDependencyError, PackageJsonNotFoundError, type ProjectInfo, ProjectNotFoundError, type ReactDoctorConfig, ReactDoctorError, type ScoreResult, buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, isReactDoctorError, summarizeDiagnostics, toJsonReport };
+export { AmbiguousProjectError, type DiagnoseOptions, type DiagnoseResult, type Diagnostic, type DiffInfo, type JsonReport, type JsonReportDiffInfo, type JsonReportError, type JsonReportMode, type JsonReportProjectEntry, type JsonReportSummary, NoReactDependencyError, PackageJsonNotFoundError, type ProjectInfo, ProjectNotFoundError, type ReactDoctorConfig, ReactDoctorError, type ScoreResult, buildJsonReport, buildJsonReportError, clearCaches, diagnose, filterSourceFiles, getDiffInfo, isProjectDiscoveryError, isReactDoctorError, summarizeDiagnostics, toJsonReport };
 //# sourceMappingURL=index.d.ts.map