@wolfcola/dead-export-finder 0.0.0-beta-20260513233134

package/README.md

@@ -0,0 +1,104 @@
+# @wolfcola/dead-export-finder
+
+Find unused exports across monorepo package boundaries. Scans all workspace packages, parses exports and imports with [oxc-parser](https://oxc.rs/), and reports exports that are never imported by any other package.
+
+## Installation
+
+```bash
+npm install -D @wolfcola/dead-export-finder
+```
+
+## CLI Usage
+
+```bash
+dead-export-finder [options]
+```
+
+Run from the monorepo root. The tool auto-detects workspace packages from `pnpm-workspace.yaml` or `package.json` workspaces.
+
+### Options
+
+| Option              | Alias | Description                                           |
+| ------------------- | ----- | ----------------------------------------------------- |
+| `--packages <name>` | `-p`  | Scope analysis to specific package names (repeatable) |
+| `--ignore <glob>`   | `-i`  | Glob patterns to exclude from scanning (repeatable)   |
+| `--verbose`         | `-v`  | Print timing, file counts, and parse warnings         |
+
+### Examples
+
+```bash
+# Scan all packages
+dead-export-finder
+
+# Scope to specific packages
+dead-export-finder -p @wolfcola/devtools-core -p @wolfcola/devtools-types
+
+# Ignore test files
+dead-export-finder -i "**/*.test.ts" -i "**/*.spec.ts"
+
+# Verbose output
+dead-export-finder --verbose
+```
+
+Exit code is `1` when dead exports are found, `0` when clean.
+
+## Programmatic API
+
+All services are exported for use in custom tooling:
+
+```typescript
+import {
+  WorkspaceDetector,
+  WorkspaceDetectorLive,
+  FileScanner,
+  FileScannerLive,
+  ExportParser,
+  ExportParserLive,
+  ImportParser,
+  ImportParserLive,
+  ExportGraph,
+  ExportGraphLive,
+  Reporter,
+  ReporterLive,
+} from '@wolfcola/dead-export-finder';
+```
+
+Each service follows the `Context.Service` + `Live` layer pattern from Effect.
+
+### Types
+
+```typescript
+import type {
+  PackageInfo,
+  ExportedSymbol,
+  ImportedSymbol,
+  DeadExport,
+  AnalysisResult,
+  WorkspaceResult,
+} from '@wolfcola/dead-export-finder';
+```
+
+### Errors
+
+```typescript
+import {
+  WorkspaceNotFoundError,
+  ParseError,
+  EntryPointResolutionError,
+} from '@wolfcola/dead-export-finder';
+```
+
+## How It Works
+
+1. **Workspace detection** — reads `pnpm-workspace.yaml` or `package.json` workspaces to find all packages
+2. **File scanning** — finds all `.ts`, `.tsx`, `.js`, `.jsx` files in each package, respecting `.gitignore` and `--ignore` globs
+3. **Export parsing** — uses `oxc-parser` to extract all exported symbols from each file
+4. **Import parsing** — uses `oxc-parser` to extract all imported symbols from each file
+5. **Graph analysis** — builds a cross-package dependency graph and identifies exports with zero imports
+6. **Reporting** — formats results grouped by package with file paths relative to package root
+
+Parse errors are handled gracefully as warnings — the tool continues with remaining files.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+export { WorkspaceDetector, WorkspaceDetectorLive } from './lib/workspace-detector.js';
+export type { WorkspaceResult } from './lib/workspace-detector.js';
+export { FileScanner, FileScannerLive } from './lib/file-scanner.js';
+export { ExportParser, ExportParserLive } from './lib/export-parser.js';
+export { ImportParser, ImportParserLive } from './lib/import-parser.js';
+export { ExportGraph, ExportGraphLive } from './lib/export-graph.js';
+export { Reporter, ReporterLive } from './lib/reporter.js';
+export { WorkspaceNotFoundError, ParseError, EntryPointResolutionError } from './lib/errors.js';
+export type { PackageInfo, ExportedSymbol, ImportedSymbol, DeadExport, AnalysisResult, } from './lib/schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACvF,YAAY,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,UAAU,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAChG,YAAY,EACV,WAAW,EACX,cAAc,EACd,cAAc,EACd,UAAU,EACV,cAAc,GACf,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// Public API
+export { WorkspaceDetector, WorkspaceDetectorLive } from './lib/workspace-detector.js';
+export { FileScanner, FileScannerLive } from './lib/file-scanner.js';
+export { ExportParser, ExportParserLive } from './lib/export-parser.js';
+export { ImportParser, ImportParserLive } from './lib/import-parser.js';
+export { ExportGraph, ExportGraphLive } from './lib/export-graph.js';
+export { Reporter, ReporterLive } from './lib/reporter.js';
+export { WorkspaceNotFoundError, ParseError, EntryPointResolutionError } from './lib/errors.js';
+import { Command, Options } from '@effect/cli';
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import { FileSystem } from '@effect/platform';
+import { Console, Data, Effect, Layer, Array as Arr, Option, pipe } from 'effect';
+import { WorkspaceDetector, WorkspaceDetectorLive } from './lib/workspace-detector.js';
+import { FileScanner, FileScannerLive } from './lib/file-scanner.js';
+import { ExportParser, ExportParserLive } from './lib/export-parser.js';
+import { ImportParser, ImportParserLive } from './lib/import-parser.js';
+import { ExportGraph, ExportGraphLive } from './lib/export-graph.js';
+import { Reporter, ReporterLive } from './lib/reporter.js';
+// ─── Exit code error ──────────────────────────────────────────────────────────
+class ExitWithCode extends Data.TaggedError('ExitWithCode') {
+}
+// ─── Options ──────────────────────────────────────────────────────────────────
+const packages = Options.text('packages').pipe(Options.withAlias('p'), Options.withDescription('Scope analysis to specific package names (repeat for multiple).'), Options.repeated, Options.optional);
+const ignore = Options.text('ignore').pipe(Options.withAlias('i'), Options.withDescription('Glob patterns to exclude from scanning (repeat for multiple).'), Options.repeated, Options.optional);
+const verbose = Options.boolean('verbose').pipe(Options.withAlias('v'), Options.withDescription('Print verbose output including timing and parse warnings.'), Options.withDefault(false));
+// ─── Layer ────────────────────────────────────────────────────────────────────
+const AppLayer = Layer.mergeAll(ExportParserLive, ImportParserLive, ExportGraphLive, ReporterLive, WorkspaceDetectorLive, FileScannerLive).pipe(Layer.provideMerge(NodeContext.layer));
+const scanWorkspace = (workspace, ignoreGlobs, isVerbose) => Effect.gen(function* () {
+    const scanner = yield* FileScanner;
+    const results = yield* Effect.all(pipe(workspace.packages, Arr.map((pkg) => pipe(scanner.scan(pkg.root, ignoreGlobs), Effect.catchTag('GlobError', (e) => Effect.gen(function* () {
+        const msg = `failed to scan files in ${pkg.root}: ${String(e.cause)}`;
+        if (isVerbose)
+            yield* Console.log(`Warning: ${msg}`);
+        return { files: [], warning: msg };
+    })), Effect.map((result) => 'warning' in result
+        ? result
+        : { files: result, warning: null }), Effect.map((r) => ({ pkg, files: r.files, warning: r.warning }))))));
+    return {
+        filesByPackage: pipe(results, Arr.map((r) => [r.pkg, r.files])),
+        warnings: pipe(results, Arr.filterMap((r) => (r.warning !== null ? Option.some(r.warning) : Option.none()))),
+    };
+});
+const parseAllFiles = (filesByPackage, isVerbose) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const exportParser = yield* ExportParser;
+    const importParser = yield* ImportParser;
+    const allFiles = pipe(filesByPackage, Arr.flatMap(([, files]) => files));
+    const fileResults = yield* Effect.all(pipe(allFiles, Arr.map((filePath) => pipe(fs.readFileString(filePath, 'utf-8'), Effect.either, Effect.flatMap((sourceResult) => {
+        if (sourceResult._tag === 'Left') {
+            const msg = `could not read ${filePath}: ${String(sourceResult.left)}`;
+            return isVerbose
+                ? pipe(Console.log(`Warning: ${msg}`), Effect.map(() => ({
+                    filePath,
+                    exports: [],
+                    imports: [],
+                    warning: msg,
+                })))
+                : Effect.succeed({
+                    filePath,
+                    exports: [],
+                    imports: [],
+                    warning: msg,
+                });
+        }
+        const source = sourceResult.right;
+        const parseExports = pipe(exportParser.parse(filePath, source), Effect.map((symbols) => ({
+            symbols,
+            warning: null,
+        })), Effect.catchTag('ParseError', (e) => {
+            const msg = `failed to parse exports in ${e.filePath}: ${e.message}`;
+            const result = { symbols: [], warning: msg };
+            return isVerbose
+                ? pipe(Console.log(`Warning: ${msg}`), Effect.map(() => result))
+                : Effect.succeed(result);
+        }));
+        const parseImports = pipe(importParser.parse(filePath, source), Effect.map((symbols) => ({
+            symbols,
+            warning: null,
+        })), Effect.catchTag('ParseError', (e) => {
+            const msg = `failed to parse imports in ${e.filePath}: ${e.message}`;
+            const result = { symbols: [], warning: msg };
+            return isVerbose
+                ? pipe(Console.log(`Warning: ${msg}`), Effect.map(() => result))
+                : Effect.succeed(result);
+        }));
+        return pipe(Effect.all({ exports: parseExports, imports: parseImports }), Effect.map(({ exports: exp, imports: imp }) => ({
+            filePath,
+            exports: exp.symbols,
+            imports: imp.symbols,
+            warning: exp.warning ?? imp.warning,
+        })));
+    })))));
+    const exportEntries = pipe(fileResults, Arr.filter((r) => r.exports.length > 0), Arr.map((r) => [r.filePath, r.exports]));
+    const importEntries = pipe(fileResults, Arr.filter((r) => r.imports.length > 0), Arr.map((r) => [r.filePath, r.imports]));
+    const warnings = pipe(fileResults, Arr.filterMap((r) => (r.warning !== null ? Option.some(r.warning) : Option.none())));
+    return {
+        allExports: new Map(exportEntries),
+        allImports: new Map(importEntries),
+        warnings,
+    };
+});
+const analyzeAndReport = (targetPackages, allPackages, allExports, allImports) => Effect.gen(function* () {
+    const graph = yield* ExportGraph;
+    const reporter = yield* Reporter;
+    const result = yield* graph.analyze(targetPackages, allExports, allImports);
+    const packageRoots = new Map(pipe(allPackages, Arr.map((p) => [p.name, p.root])));
+    const report = reporter.format(result, packageRoots);
+    yield* Console.log(report);
+    return { deadCount: result.deadExports.length, warnings: result.warnings };
+});
+// ─── Command ──────────────────────────────────────────────────────────────────
+const command = Command.make('dead-export-finder', { packages, ignore, verbose }, ({ packages: packagesOpt, ignore: ignoreOpt, verbose: isVerbose }) => Effect.gen(function* () {
+    const startTime = Date.now();
+    const detector = yield* WorkspaceDetector;
+    const cwd = process.cwd();
+    const workspace = yield* detector.detect(cwd);
+    if (isVerbose) {
+        yield* Console.log(`Detected workspace type: ${workspace.type}`);
+        yield* Console.log(`Found ${workspace.packages.length} packages`);
+    }
+    const packageFilter = packagesOpt._tag === 'Some' ? new Set(packagesOpt.value) : null;
+    const targetPackages = packageFilter !== null
+        ? pipe(workspace.packages, Arr.filter((p) => packageFilter.has(p.name)))
+        : [...workspace.packages];
+    const ignoreGlobs = ignoreOpt._tag === 'Some' ? ignoreOpt.value : [];
+    if (isVerbose && packageFilter !== null && targetPackages.length > 0) {
+        yield* Console.log(`Scoping to packages: ${pipe(targetPackages, Arr.map((p) => p.name), Arr.join(', '))}`);
+    }
+    const scanResult = yield* scanWorkspace(workspace, ignoreGlobs, isVerbose);
+    const parseResult = yield* parseAllFiles(scanResult.filesByPackage, isVerbose);
+    if (isVerbose) {
+        yield* Console.log(`Scanned ${parseResult.allExports.size} files with exports, ${parseResult.allImports.size} files with imports`);
+    }
+    const { deadCount, warnings: analysisWarnings } = yield* analyzeAndReport(targetPackages, [...workspace.packages], parseResult.allExports, parseResult.allImports);
+    const allWarnings = pipe(scanResult.warnings, Arr.appendAll(parseResult.warnings), Arr.appendAll(analysisWarnings));
+    if (allWarnings.length > 0 && !isVerbose) {
+        yield* Console.log(`\nWarning: ${allWarnings.length} issue(s) during analysis — results may be incomplete. Run with --verbose for details.`);
+    }
+    if (isVerbose) {
+        const elapsed = Date.now() - startTime;
+        yield* Console.log(`\nCompleted in ${elapsed}ms`);
+    }
+    if (deadCount > 0) {
+        return yield* new ExitWithCode({ code: 1 });
+    }
+})).pipe(Command.withDescription('Find dead exports across monorepo package boundaries.'));
+// ─── Runner ───────────────────────────────────────────────────────────────────
+const cli = Command.run(command, {
+    name: 'Dead Export Finder',
+    version: '0.0.0',
+});
+cli(process.argv).pipe(Effect.catchTags({
+    ExitWithCode: (e) => Effect.sync(() => (process.exitCode = e.code)),
+    WorkspaceNotFoundError: (e) => Console.error(`error: workspace not found at ${e.cwd}`).pipe(Effect.zipRight(Effect.sync(() => {
+        process.exitCode = 1;
+    }))),
+}), Effect.provide(AppLayer), NodeRuntime.runMain);

package/dist/lib/errors.d.ts

@@ -0,0 +1,25 @@
+declare const WorkspaceNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "WorkspaceNotFoundError";
+} & Readonly<A>;
+export declare class WorkspaceNotFoundError extends WorkspaceNotFoundError_base<{
+    readonly cwd: string;
+}> {
+}
+declare const ParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ParseError";
+} & Readonly<A>;
+export declare class ParseError extends ParseError_base<{
+    readonly filePath: string;
+    readonly message: string;
+}> {
+}
+declare const EntryPointResolutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EntryPointResolutionError";
+} & Readonly<A>;
+export declare class EntryPointResolutionError extends EntryPointResolutionError_base<{
+    readonly packageName: string;
+    readonly entryPoint: string;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,sBAAuB,SAAQ,4BAA2C;IACrF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;CAAG;;;;AAEL,qBAAa,UAAW,SAAQ,gBAA+B;IAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,yBAA0B,SAAQ,+BAA8C;IAC3F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;CAAG"}

package/dist/lib/errors.js

@@ -0,0 +1,7 @@
+import { Data } from 'effect';
+export class WorkspaceNotFoundError extends Data.TaggedError('WorkspaceNotFoundError') {
+}
+export class ParseError extends Data.TaggedError('ParseError') {
+}
+export class EntryPointResolutionError extends Data.TaggedError('EntryPointResolutionError') {
+}

package/dist/lib/export-graph.d.ts

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from 'effect';
+import type { PackageInfo, ExportedSymbol, ImportedSymbol, AnalysisResult } from './schemas.js';
+export interface ExportGraphShape {
+    readonly analyze: (packages: readonly PackageInfo[], allExports: ReadonlyMap<string, readonly ExportedSymbol[]>, allImports: ReadonlyMap<string, readonly ImportedSymbol[]>) => Effect.Effect<AnalysisResult>;
+}
+declare const ExportGraph_base: Context.TagClass<ExportGraph, "ExportGraph", ExportGraphShape>;
+export declare class ExportGraph extends ExportGraph_base {
+}
+export declare const ExportGraphLive: Layer.Layer<ExportGraph, never, never>;
+export {};
+//# sourceMappingURL=export-graph.d.ts.map

package/dist/lib/export-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-graph.d.ts","sourceRoot":"","sources":["../../src/lib/export-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAuC,MAAM,QAAQ,CAAC;AAErF,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,cAAc,EAEd,cAAc,EACf,MAAM,cAAc,CAAC;AAkQtB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,CAChB,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC,EAC1D,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC,KACvD,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;CACpC;;AAID,qBAAa,WAAY,SAAQ,gBAA2D;CAAG;AA6B/F,eAAO,MAAM,eAAe,wCAG1B,CAAC"}

package/dist/lib/export-graph.js

@@ -0,0 +1,125 @@
+import { Context, Effect, Layer, Array as Arr, HashSet, Option, pipe } from 'effect';
+import path from 'node:path';
+// ─── Extension stripping ───────────────────────────────────────────────────────
+const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const stripExtension = (filePath) => pipe(EXTENSIONS, Arr.findFirst((ext) => filePath.endsWith(ext)), (opt) => (opt._tag === 'Some' ? filePath.slice(0, -opt.value.length) : filePath));
+const BUILD_DIR_MAPPINGS = [
+    ['/dist/', '/src/'],
+    ['/build/', '/src/'],
+    ['/out/', '/src/'],
+];
+const resolveEntryPointToSource = (entryPoint, scannedFiles, scannedStripped) => {
+    if (HashSet.has(scannedFiles, entryPoint))
+        return entryPoint;
+    const stripped = stripExtension(entryPoint);
+    if (HashSet.has(scannedStripped, stripped))
+        return stripped;
+    return pipe(BUILD_DIR_MAPPINGS, Arr.findFirst(([buildDir]) => entryPoint.includes(buildDir)), (opt) => {
+        if (opt._tag === 'None')
+            return null;
+        const [buildDir, sourceDir] = opt.value;
+        const sourcePath = entryPoint.replace(buildDir, sourceDir);
+        if (HashSet.has(scannedFiles, sourcePath))
+            return sourcePath;
+        const sourceStripped = stripExtension(sourcePath);
+        if (HashSet.has(scannedStripped, sourceStripped))
+            return sourceStripped;
+        return null;
+    });
+};
+// ─── Pure pipeline stages ────────────────────────────────────────────────────
+const resolveEntryPoints = (packages, scannedFiles, scannedStripped) => pipe(packages, Arr.flatMap((pkg) => pipe(pkg.entryPoints, Arr.filterMap((ep) => {
+    const resolved = path.resolve(pkg.root, ep);
+    const sourcePath = resolveEntryPointToSource(resolved, scannedFiles, scannedStripped);
+    return sourcePath !== null ? Option.some(sourcePath) : Option.none();
+}))), HashSet.fromIterable);
+const buildFileToPackageMap = (packages, exportedFilePaths) => new Map(pipe(exportedFilePaths, Arr.filterMap((filePath) => {
+    const pkg = pipe(packages, Arr.findFirst((p) => filePath.startsWith(p.root + path.sep) || filePath === p.root));
+    return pkg._tag === 'Some' ? Option.some([filePath, pkg.value]) : Option.none();
+})));
+const isRelativePath = (src) => src.startsWith('./') || src.startsWith('../') || src.startsWith('/');
+const collectImportEdges = (allImports) => {
+    const entries = pipe([...allImports.entries()], Arr.flatMap(([importerFile, imports]) => pipe(imports, Arr.map((imp) => ({ importerFile, imp })))));
+    const relativeEntries = pipe(entries, Arr.filter(({ imp }) => isRelativePath(imp.source)));
+    const packageEntries = pipe(entries, Arr.filter(({ imp }) => !isRelativePath(imp.source)));
+    const byRelative = pipe(relativeEntries, Arr.filter(({ imp }) => !imp.isNamespace && imp.name !== '*'), Arr.map(({ importerFile, imp }) => {
+        const importerDir = path.dirname(importerFile);
+        const resolved = stripExtension(path.resolve(importerDir, imp.source));
+        return `${resolved}:${imp.name}`;
+    }), HashSet.fromIterable);
+    const byPackage = pipe(packageEntries, Arr.filter(({ imp }) => !imp.isNamespace && imp.name !== '*'), Arr.map(({ imp }) => `${imp.source}:${imp.name}`), HashSet.fromIterable);
+    const relativeNamespaces = pipe(relativeEntries, Arr.filter(({ imp }) => imp.isNamespace || imp.name === '*'), Arr.map(({ importerFile, imp }) => {
+        const importerDir = path.dirname(importerFile);
+        return stripExtension(path.resolve(importerDir, imp.source));
+    }));
+    const packageNamespaces = pipe(packageEntries, Arr.filter(({ imp }) => imp.isNamespace || imp.name === '*'), Arr.map(({ imp }) => imp.source));
+    const byNamespace = pipe([...relativeNamespaces, ...packageNamespaces], HashSet.fromIterable);
+    return { byRelative, byPackage, byNamespace };
+};
+const collectReExportEdges = (allExports) => {
+    const reExports = pipe([...allExports.entries()], Arr.flatMap(([filePath, exports]) => pipe(exports, Arr.filter((exp) => exp.isReExport && exp.reExportSource !== undefined), Arr.filter((exp) => isRelativePath(exp.reExportSource)), Arr.map((exp) => ({ filePath, exp })))));
+    const byNamespace = pipe(reExports, Arr.filter(({ exp }) => exp.name === '*'), Arr.map(({ filePath, exp }) => {
+        const dir = path.dirname(filePath);
+        return stripExtension(path.resolve(dir, exp.reExportSource));
+    }), HashSet.fromIterable);
+    const byRelative = pipe(reExports, Arr.filter(({ exp }) => exp.name !== '*'), Arr.map(({ filePath, exp }) => {
+        const dir = path.dirname(filePath);
+        const resolved = stripExtension(path.resolve(dir, exp.reExportSource));
+        const consumedName = exp.reExportLocalName ?? exp.name;
+        return `${resolved}:${consumedName}`;
+    }), HashSet.fromIterable);
+    return {
+        byRelative,
+        byPackage: HashSet.empty(),
+        byNamespace,
+    };
+};
+const mergeConsumedSets = (a, b) => ({
+    byRelative: HashSet.union(a.byRelative, b.byRelative),
+    byPackage: HashSet.union(a.byPackage, b.byPackage),
+    byNamespace: HashSet.union(a.byNamespace, b.byNamespace),
+});
+const buildConsumedSets = (allImports, allExports) => mergeConsumedSets(collectImportEdges(allImports), collectReExportEdges(allExports));
+// ─── Dead export detection ──────────────────────────────────────────────────
+const isConsumed = (exp, strippedFilePath, pkg, consumed) => {
+    if (exp.name === '*')
+        return true;
+    if (HashSet.has(consumed.byRelative, `${strippedFilePath}:${exp.name}`))
+        return true;
+    if (HashSet.has(consumed.byPackage, `${pkg.name}:${exp.name}`))
+        return true;
+    if (HashSet.has(consumed.byNamespace, strippedFilePath))
+        return true;
+    if (HashSet.has(consumed.byNamespace, pkg.name))
+        return true;
+    return false;
+};
+const findDeadExports = (allExports, entryPoints, fileToPackage, consumed) => pipe([...allExports.entries()], Arr.filter(([filePath]) => !HashSet.has(entryPoints, filePath)), Arr.flatMap(([filePath, exports]) => {
+    const pkg = fileToPackage.get(filePath);
+    if (pkg === undefined)
+        return [];
+    const strippedFilePath = stripExtension(filePath);
+    return pipe(exports, Arr.filter((exp) => !isConsumed(exp, strippedFilePath, pkg, consumed)), Arr.map((exp) => ({ symbol: exp, packageName: pkg.name })));
+}));
+const countTotalExports = (allExports) => pipe([...allExports.values()], Arr.map((exports) => exports.length), Arr.reduce(0, (acc, n) => acc + n));
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class ExportGraph extends Context.Tag('ExportGraph')() {
+}
+// ─── Live implementation ──────────────────────────────────────────────────────
+const analyze = (packages, allExports, allImports) => {
+    const scannedFiles = HashSet.fromIterable(allExports.keys());
+    const scannedStripped = pipe([...allExports.keys()], Arr.map(stripExtension), HashSet.fromIterable);
+    const entryPoints = resolveEntryPoints(packages, scannedFiles, scannedStripped);
+    const fileToPackage = buildFileToPackageMap(packages, [...allExports.keys()]);
+    const consumed = buildConsumedSets(allImports, allExports);
+    const deadExports = findDeadExports(allExports, entryPoints, fileToPackage, consumed);
+    return {
+        deadExports: [...deadExports],
+        totalExports: countTotalExports(allExports),
+        totalFiles: allExports.size,
+        warnings: [],
+    };
+};
+export const ExportGraphLive = Layer.succeed(ExportGraph, {
+    analyze: (packages, allExports, allImports) => Effect.sync(() => analyze(packages, allExports, allImports)),
+});

package/dist/lib/export-parser.d.ts

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from 'effect';
+import type { ExportedSymbol } from './schemas.js';
+import { ParseError } from './errors.js';
+export interface ExportParserShape {
+    readonly parse: (filePath: string, source: string) => Effect.Effect<readonly ExportedSymbol[], ParseError>;
+}
+declare const ExportParser_base: Context.TagClass<ExportParser, "ExportParser", ExportParserShape>;
+export declare class ExportParser extends ExportParser_base {
+}
+export declare const ExportParserLive: Layer.Layer<ExportParser, never, never>;
+export {};
+//# sourceMappingURL=export-parser.d.ts.map

package/dist/lib/export-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-parser.d.ts","sourceRoot":"","sources":["../../src/lib/export-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAsB,MAAM,QAAQ,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwUzC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,CACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,SAAS,cAAc,EAAE,EAAE,UAAU,CAAC,CAAC;CAC3D;;AAID,qBAAa,YAAa,SAAQ,iBAA8D;CAAG;AA+BnG,eAAO,MAAM,gBAAgB,yCAE3B,CAAC"}

package/dist/lib/export-parser.js

@@ -0,0 +1,170 @@
+import { Context, Effect, Layer, Array as Arr, pipe } from 'effect';
+import oxc from 'oxc-parser';
+import { ParseError } from './errors.js';
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+const lineFromOffset = (source, offset) => pipe(source.slice(0, offset).split('\n'), Arr.length);
+const extractDeclarationNames = (decl) => {
+    switch (decl.type) {
+        case 'FunctionDeclaration':
+        case 'ClassDeclaration': {
+            const d = decl;
+            return d.id ? [d.id.name] : [];
+        }
+        case 'VariableDeclaration': {
+            const d = decl;
+            return pipe(d.declarations, Arr.flatMap((v) => (v.id.type === 'Identifier' ? [v.id.name] : [])));
+        }
+        case 'TSTypeAliasDeclaration':
+        case 'TSInterfaceDeclaration': {
+            const d = decl;
+            return [d.id.name];
+        }
+        default:
+            return [];
+    }
+};
+const extractNamedDeclaration = (node, filePath, source) => {
+    const isReExport = node.source !== null;
+    const reExportSource = node.source ? String(node.source.value) : undefined;
+    if (node.declaration !== null) {
+        return pipe(extractDeclarationNames(node.declaration), Arr.map((name) => ({
+            name,
+            filePath,
+            line: lineFromOffset(source, node.start),
+            isDefault: false,
+            isReExport: false,
+        })));
+    }
+    return pipe(node.specifiers, Arr.map((spec) => {
+        const localName = spec.local?.name;
+        const isRenamed = localName !== undefined && localName !== spec.exported.name;
+        return {
+            name: spec.exported.name,
+            filePath,
+            line: lineFromOffset(source, spec.start),
+            isDefault: false,
+            isReExport,
+            ...(reExportSource !== undefined ? { reExportSource } : {}),
+            ...(isRenamed ? { reExportLocalName: localName } : {}),
+        };
+    }));
+};
+const extractDefaultDeclaration = (node, filePath, source) => [
+    {
+        name: 'default',
+        filePath,
+        line: lineFromOffset(source, node.start),
+        isDefault: true,
+        isReExport: false,
+    },
+];
+const extractAllDeclaration = (node, filePath, source) => [
+    {
+        name: node.exported ? node.exported.name : '*',
+        filePath,
+        line: lineFromOffset(source, node.start),
+        isDefault: false,
+        isReExport: true,
+        reExportSource: String(node.source.value),
+    },
+];
+const extractCjsExports = (node, filePath, source) => {
+    const expr = node.expression;
+    if (expr.type !== 'AssignmentExpression')
+        return [];
+    const assign = expr;
+    const left = assign.left;
+    if (left.type !== 'MemberExpression')
+        return [];
+    const member = left;
+    const objName = member.object.type === 'Identifier' ? member.object.name : '';
+    const propName = member.property.name;
+    // exports.foo = ...
+    if (objName === 'exports') {
+        return [
+            {
+                name: propName,
+                filePath,
+                line: lineFromOffset(source, assign.start),
+                isDefault: false,
+                isReExport: false,
+            },
+        ];
+    }
+    // module.exports.foo = ... (nested MemberExpression)
+    if (member.object.type === 'MemberExpression') {
+        const inner = member.object;
+        const innerObj = inner.object.type === 'Identifier' ? inner.object.name : '';
+        const innerProp = inner.property.name;
+        if (innerObj === 'module' && innerProp === 'exports') {
+            return [
+                {
+                    name: propName,
+                    filePath,
+                    line: lineFromOffset(source, assign.start),
+                    isDefault: false,
+                    isReExport: false,
+                },
+            ];
+        }
+    }
+    // module.exports = { foo, bar }
+    if (objName === 'module' && propName === 'exports') {
+        const right = assign.right;
+        if (right.type !== 'ObjectExpression')
+            return [];
+        const obj = right;
+        return pipe(obj.properties, Arr.flatMap((prop) => {
+            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+                const key = prop.key;
+                return [
+                    {
+                        name: key.name,
+                        filePath,
+                        line: lineFromOffset(source, prop.start),
+                        isDefault: false,
+                        isReExport: false,
+                    },
+                ];
+            }
+            return [];
+        }));
+    }
+    return [];
+};
+const extractExportsFromNode = (node, filePath, source) => {
+    switch (node.type) {
+        case 'ExportNamedDeclaration':
+            return extractNamedDeclaration(node, filePath, source);
+        case 'ExportDefaultDeclaration':
+            return extractDefaultDeclaration(node, filePath, source);
+        case 'ExportAllDeclaration':
+            return extractAllDeclaration(node, filePath, source);
+        case 'ExpressionStatement':
+            return extractCjsExports(node, filePath, source);
+        default:
+            return [];
+    }
+};
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class ExportParser extends Context.Tag('ExportParser')() {
+}
+// ─── Live implementation ──────────────────────────────────────────────────────
+const parseSource = (filePath, source) => Effect.try({
+    try: () => {
+        const result = oxc.parseSync(filePath, source);
+        if (result.errors.length > 0) {
+            const msg = result.errors[0].message ?? 'parse error';
+            throw new Error(msg);
+        }
+        const program = result.program;
+        return pipe(program.body, Arr.flatMap((node) => extractExportsFromNode(node, filePath, source)));
+    },
+    catch: (e) => new ParseError({
+        filePath,
+        message: e instanceof Error ? e.message : String(e),
+    }),
+});
+export const ExportParserLive = Layer.succeed(ExportParser, {
+    parse: parseSource,
+});

package/dist/lib/file-scanner.d.ts

@@ -0,0 +1,18 @@
+import { Context, Effect, Layer } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+declare const GlobError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GlobError";
+} & Readonly<A>;
+declare class GlobError extends GlobError_base<{
+    readonly cause: unknown;
+}> {
+}
+export interface FileScannerShape {
+    readonly scan: (root: string, ignoreGlobs: readonly string[]) => Effect.Effect<readonly string[], GlobError>;
+}
+declare const FileScanner_base: Context.TagClass<FileScanner, "FileScanner", FileScannerShape>;
+export declare class FileScanner extends FileScanner_base {
+}
+export declare const FileScannerLive: Layer.Layer<FileScanner, never, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=file-scanner.d.ts.map

package/dist/lib/file-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-scanner.d.ts","sourceRoot":"","sources":["../../src/lib/file-scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAsB,MAAM,QAAQ,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;;;;AAMpD,cAAM,SAAU,SAAQ,eAA8B;IACpD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;AAmEL,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,CACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,SAAS,MAAM,EAAE,KAC3B,MAAM,CAAC,MAAM,CAAC,SAAS,MAAM,EAAE,EAAE,SAAS,CAAC,CAAC;CAClD;;AAID,qBAAa,WAAY,SAAQ,gBAA2D;CAAG;AAI/F,eAAO,MAAM,eAAe,oEAuB3B,CAAC"}

package/dist/lib/file-scanner.js

@@ -0,0 +1,42 @@
+import { Context, Data, Effect, Layer, Array as Arr, pipe } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import fg from 'fast-glob';
+import ignore from 'ignore';
+// ─── Internal errors ──────────────────────────────────────────────────────────
+class GlobError extends Data.TaggedError('GlobError') {
+}
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+const loadGitignorePatterns = (fs, pathSvc, root) => {
+    const gitignorePath = pathSvc.join(root, '.gitignore');
+    return pipe(fs.exists(gitignorePath), Effect.orElseSucceed(() => false), Effect.flatMap((exists) => exists
+        ? pipe(fs.readFileString(gitignorePath, 'utf-8'), Effect.orElseSucceed(() => ''), Effect.map((content) => content.split('\n')))
+        : Effect.succeed([])));
+};
+const buildIgnorePatterns = (gitignorePatterns, customGlobs) => pipe(['node_modules'], Arr.appendAll(gitignorePatterns), Arr.appendAll(customGlobs));
+const discoverFiles = (root) => Effect.tryPromise({
+    try: () => fg('**/*.{ts,tsx,js,jsx,mjs,cjs}', {
+        cwd: root,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ['**/node_modules/**'],
+    }),
+    catch: (cause) => new GlobError({ cause }),
+});
+const filterWithIgnore = (files, patterns, pathSvc, root) => {
+    const ig = ignore();
+    ig.add([...patterns]);
+    return pipe(files, Arr.filter((absPath) => {
+        const rel = pathSvc.relative(root, absPath);
+        return !ig.ignores(rel);
+    }));
+};
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class FileScanner extends Context.Tag('FileScanner')() {
+}
+// ─── Live implementation ──────────────────────────────────────────────────────
+export const FileScannerLive = Layer.effect(FileScanner, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathSvc = yield* Path.Path;
+    const scan = (root, ignoreGlobs) => pipe(loadGitignorePatterns(fs, pathSvc, root), Effect.map((gitignorePatterns) => buildIgnorePatterns(gitignorePatterns, ignoreGlobs)), Effect.flatMap((patterns) => pipe(discoverFiles(root), Effect.map((files) => filterWithIgnore(files, patterns, pathSvc, root)))));
+    return { scan };
+}));

package/dist/lib/import-parser.d.ts

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from 'effect';
+import type { ImportedSymbol } from './schemas.js';
+import { ParseError } from './errors.js';
+export interface ImportParserShape {
+    readonly parse: (filePath: string, source: string) => Effect.Effect<readonly ImportedSymbol[], ParseError>;
+}
+declare const ImportParser_base: Context.TagClass<ImportParser, "ImportParser", ImportParserShape>;
+export declare class ImportParser extends ImportParser_base {
+}
+export declare const ImportParserLive: Layer.Layer<ImportParser, never, never>;
+export {};
+//# sourceMappingURL=import-parser.d.ts.map

package/dist/lib/import-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-parser.d.ts","sourceRoot":"","sources":["../../src/lib/import-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAsB,MAAM,QAAQ,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4LzC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,CACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,SAAS,cAAc,EAAE,EAAE,UAAU,CAAC,CAAC;CAC3D;;AAID,qBAAa,YAAa,SAAQ,iBAA8D;CAAG;AAsCnG,eAAO,MAAM,gBAAgB,yCAE3B,CAAC"}

package/dist/lib/import-parser.js

@@ -0,0 +1,129 @@
+import { Context, Effect, Layer, Array as Arr, pipe } from 'effect';
+import oxc from 'oxc-parser';
+import { ParseError } from './errors.js';
+// ─── Pure extractors ─────────────────────────────────────────────────────────
+const extractSpecifier = (spec, filePath, importSource) => {
+    switch (spec.type) {
+        case 'ImportSpecifier': {
+            const s = spec;
+            return [
+                {
+                    name: s.imported.name,
+                    filePath,
+                    source: importSource,
+                    isNamespace: false,
+                    isDynamic: false,
+                },
+            ];
+        }
+        case 'ImportDefaultSpecifier':
+            return [
+                {
+                    name: 'default',
+                    filePath,
+                    source: importSource,
+                    isNamespace: false,
+                    isDynamic: false,
+                },
+            ];
+        case 'ImportNamespaceSpecifier':
+            return [
+                {
+                    name: '*',
+                    filePath,
+                    source: importSource,
+                    isNamespace: true,
+                    isDynamic: false,
+                },
+            ];
+        default:
+            return [];
+    }
+};
+const extractStaticImports = (node, filePath) => {
+    if (node.type !== 'ImportDeclaration')
+        return [];
+    const n = node;
+    if (n.specifiers.length === 0)
+        return [];
+    return pipe(n.specifiers, Arr.flatMap((spec) => extractSpecifier(spec, filePath, n.source.value)));
+};
+const collectSymbols = (node, filePath) => {
+    if (node === null || typeof node !== 'object')
+        return [];
+    if (node.type === 'ImportExpression') {
+        const n = node;
+        if (n.source.type === 'Literal') {
+            const lit = n.source;
+            return [
+                {
+                    name: '*',
+                    filePath,
+                    source: lit.value,
+                    isNamespace: false,
+                    isDynamic: true,
+                },
+            ];
+        }
+        return [];
+    }
+    const currentSymbols = node.type === 'CallExpression'
+        ? extractRequireCall(node, filePath)
+        : [];
+    const childSymbols = pipe(Object.keys(node), Arr.flatMap((key) => {
+        const child = node[key];
+        if (Array.isArray(child)) {
+            return pipe(child, Arr.filter((item) => item !== null && typeof item === 'object' && typeof item.type === 'string'), Arr.flatMap((item) => collectSymbols(item, filePath)));
+        }
+        if (child !== null &&
+            typeof child === 'object' &&
+            typeof child.type === 'string') {
+            return collectSymbols(child, filePath);
+        }
+        return [];
+    }));
+    return pipe(currentSymbols, Arr.appendAll(childSymbols));
+};
+const extractRequireCall = (node, filePath) => {
+    const callee = node.callee;
+    if (callee.type === 'Identifier' && callee.name === 'require') {
+        const arg = node.arguments[0];
+        if (arg !== undefined && arg.type === 'Literal') {
+            const lit = arg;
+            return [
+                {
+                    name: '*',
+                    filePath,
+                    source: lit.value,
+                    isNamespace: true,
+                    isDynamic: false,
+                },
+            ];
+        }
+    }
+    return [];
+};
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class ImportParser extends Context.Tag('ImportParser')() {
+}
+// ─── Live implementation ──────────────────────────────────────────────────────
+const parseSource = (filePath, source) => Effect.try({
+    try: () => {
+        const result = oxc.parseSync(filePath, source);
+        if (result.errors.length > 0) {
+            const msg = result.errors[0].message ?? 'parse error';
+            throw new Error(msg);
+        }
+        const program = result.program;
+        const staticImports = pipe(program.body, Arr.flatMap((node) => extractStaticImports(node, filePath)));
+        const dynamicImports = pipe(program.body, Arr.flatMap((node) => collectSymbols(node, filePath)));
+        return pipe(staticImports, Arr.appendAll(dynamicImports));
+    },
+    catch: (e) => new ParseError({
+        filePath,
+        message: e instanceof Error ? e.message : String(e),
+    }),
+});
+export const ImportParserLive = Layer.succeed(ImportParser, {
+    parse: parseSource,
+});

package/dist/lib/reporter.d.ts

@@ -0,0 +1,11 @@
+import { Context, Layer } from 'effect';
+import type { AnalysisResult } from './schemas.js';
+export interface ReporterShape {
+    readonly format: (result: AnalysisResult, packageRoots: ReadonlyMap<string, string>) => string;
+}
+declare const Reporter_base: Context.TagClass<Reporter, "Reporter", ReporterShape>;
+export declare class Reporter extends Reporter_base {
+}
+export declare const ReporterLive: Layer.Layer<Reporter, never, never>;
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/dist/lib/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../src/lib/reporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAA6B,MAAM,QAAQ,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,cAAc,CAAC;AA4F/D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;CAChG;;AAID,qBAAa,QAAS,SAAQ,aAAkD;CAAG;AAInF,eAAO,MAAM,YAAY,qCAEvB,CAAC"}

package/dist/lib/reporter.js

@@ -0,0 +1,50 @@
+import { Context, Layer, Array as Arr, Order, pipe } from 'effect';
+import path from 'node:path';
+// ─── Pure formatting helpers ─────────────────────────────────────────────────
+const pluralize = (count, singular, plural) => count === 1 ? singular : plural;
+const formatFileSection = (filePath, fileExports, pkgRoot) => {
+    const relPath = pkgRoot ? path.relative(pkgRoot, filePath) : filePath;
+    const sorted = pipe(fileExports, Arr.sort(Order.mapInput(Order.number, (d) => d.symbol.line)));
+    return [
+        `  ${relPath}`,
+        ...pipe(sorted, Arr.map((dead) => `    :${String(dead.symbol.line).padEnd(4)} ${dead.symbol.name}`)),
+    ];
+};
+const formatPackageSection = (pkgName, pkgDeadExports, packageRoots) => {
+    const pkgRoot = packageRoots.get(pkgName) ?? '';
+    const count = pkgDeadExports.length;
+    const exportWord = pluralize(count, 'dead export', 'dead exports');
+    const byFile = pipe(pkgDeadExports, Arr.groupBy((dead) => dead.symbol.filePath));
+    const sortedFiles = pipe(Object.keys(byFile), Arr.sort(Order.string));
+    return [
+        `${pkgName} (${count} ${exportWord})`,
+        ...pipe(sortedFiles, Arr.flatMap((filePath) => formatFileSection(filePath, byFile[filePath], pkgRoot))),
+        '',
+    ];
+};
+const formatReport = (result, packageRoots) => {
+    const { deadExports, totalExports, totalFiles } = result;
+    if (deadExports.length === 0) {
+        return `No dead exports found. Scanned ${totalExports} exports across ${totalFiles} files.`;
+    }
+    const byPackage = pipe(deadExports, Arr.groupBy((dead) => dead.packageName));
+    const sortedPackages = pipe(Object.keys(byPackage), Arr.sort(Order.string));
+    const header = ['Dead Export Report', '══════════════════', ''];
+    const packageSections = pipe(sortedPackages, Arr.flatMap((pkgName) => formatPackageSection(pkgName, byPackage[pkgName], packageRoots)));
+    const totalDead = deadExports.length;
+    const pkgCount = sortedPackages.length;
+    const deadWord = pluralize(totalDead, 'dead export', 'dead exports');
+    const pkgWord = pluralize(pkgCount, 'package', 'packages');
+    const summary = [
+        '────────────────────────────',
+        `Summary: ${totalDead} ${deadWord} across ${pkgCount} ${pkgWord}`,
+    ];
+    return pipe(header, Arr.appendAll(packageSections), Arr.appendAll(summary), Arr.join('\n'));
+};
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class Reporter extends Context.Tag('Reporter')() {
+}
+// ─── Live implementation ──────────────────────────────────────────────────────
+export const ReporterLive = Layer.succeed(Reporter, {
+    format: formatReport,
+});

package/dist/lib/schemas.d.ts

@@ -0,0 +1,59 @@
+import { Schema } from 'effect';
+export declare const WorkspaceType: Schema.Literal<["pnpm", "npm", "yarn", "nx", "turborepo", "single"]>;
+export type WorkspaceType = typeof WorkspaceType.Type;
+export declare const PackageInfo: Schema.Struct<{
+    name: typeof Schema.String;
+    root: typeof Schema.String;
+    entryPoints: Schema.Array$<typeof Schema.String>;
+}>;
+export type PackageInfo = Schema.Schema.Type<typeof PackageInfo>;
+export declare const ExportedSymbol: Schema.Struct<{
+    name: typeof Schema.String;
+    filePath: typeof Schema.String;
+    line: typeof Schema.Number;
+    isDefault: typeof Schema.Boolean;
+    isReExport: typeof Schema.Boolean;
+    reExportSource: Schema.optional<typeof Schema.String>;
+    reExportLocalName: Schema.optional<typeof Schema.String>;
+}>;
+export type ExportedSymbol = Schema.Schema.Type<typeof ExportedSymbol>;
+export declare const ImportedSymbol: Schema.Struct<{
+    name: typeof Schema.String;
+    filePath: typeof Schema.String;
+    source: typeof Schema.String;
+    isNamespace: typeof Schema.Boolean;
+    isDynamic: typeof Schema.Boolean;
+}>;
+export type ImportedSymbol = Schema.Schema.Type<typeof ImportedSymbol>;
+export declare const DeadExport: Schema.Struct<{
+    symbol: Schema.Struct<{
+        name: typeof Schema.String;
+        filePath: typeof Schema.String;
+        line: typeof Schema.Number;
+        isDefault: typeof Schema.Boolean;
+        isReExport: typeof Schema.Boolean;
+        reExportSource: Schema.optional<typeof Schema.String>;
+        reExportLocalName: Schema.optional<typeof Schema.String>;
+    }>;
+    packageName: typeof Schema.String;
+}>;
+export type DeadExport = Schema.Schema.Type<typeof DeadExport>;
+export declare const AnalysisResult: Schema.Struct<{
+    deadExports: Schema.Array$<Schema.Struct<{
+        symbol: Schema.Struct<{
+            name: typeof Schema.String;
+            filePath: typeof Schema.String;
+            line: typeof Schema.Number;
+            isDefault: typeof Schema.Boolean;
+            isReExport: typeof Schema.Boolean;
+            reExportSource: Schema.optional<typeof Schema.String>;
+            reExportLocalName: Schema.optional<typeof Schema.String>;
+        }>;
+        packageName: typeof Schema.String;
+    }>>;
+    totalExports: typeof Schema.Number;
+    totalFiles: typeof Schema.Number;
+    warnings: Schema.Array$<typeof Schema.String>;
+}>;
+export type AnalysisResult = Schema.Schema.Type<typeof AnalysisResult>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/lib/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,aAAa,sEAAqE,CAAC;AAEhG,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAC;AAEtD,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjE,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvE,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;EAGrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;EAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/lib/schemas.js

@@ -0,0 +1,33 @@
+import { Schema } from 'effect';
+export const WorkspaceType = Schema.Literal('pnpm', 'npm', 'yarn', 'nx', 'turborepo', 'single');
+export const PackageInfo = Schema.Struct({
+    name: Schema.String,
+    root: Schema.String,
+    entryPoints: Schema.Array(Schema.String),
+});
+export const ExportedSymbol = Schema.Struct({
+    name: Schema.String,
+    filePath: Schema.String,
+    line: Schema.Number,
+    isDefault: Schema.Boolean,
+    isReExport: Schema.Boolean,
+    reExportSource: Schema.optional(Schema.String),
+    reExportLocalName: Schema.optional(Schema.String),
+});
+export const ImportedSymbol = Schema.Struct({
+    name: Schema.String,
+    filePath: Schema.String,
+    source: Schema.String,
+    isNamespace: Schema.Boolean,
+    isDynamic: Schema.Boolean,
+});
+export const DeadExport = Schema.Struct({
+    symbol: ExportedSymbol,
+    packageName: Schema.String,
+});
+export const AnalysisResult = Schema.Struct({
+    deadExports: Schema.Array(DeadExport),
+    totalExports: Schema.Number,
+    totalFiles: Schema.Number,
+    warnings: Schema.Array(Schema.String),
+});

package/dist/lib/workspace-detector.d.ts

@@ -0,0 +1,18 @@
+import { Context, Effect, Layer } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import type { PackageInfo, WorkspaceType } from './schemas.js';
+import { WorkspaceNotFoundError } from './errors.js';
+export interface WorkspaceResult {
+    readonly type: WorkspaceType;
+    readonly root: string;
+    readonly packages: readonly PackageInfo[];
+}
+export interface WorkspaceDetectorShape {
+    readonly detect: (cwd: string) => Effect.Effect<WorkspaceResult, WorkspaceNotFoundError>;
+}
+declare const WorkspaceDetector_base: Context.TagClass<WorkspaceDetector, "WorkspaceDetector", WorkspaceDetectorShape>;
+export declare class WorkspaceDetector extends WorkspaceDetector_base {
+}
+export declare const WorkspaceDetectorLive: Layer.Layer<WorkspaceDetector, never, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=workspace-detector.d.ts.map

package/dist/lib/workspace-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-detector.d.ts","sourceRoot":"","sources":["../../src/lib/workspace-detector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAsC,MAAM,QAAQ,CAAC;AAC1F,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAMrD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAC3C;AAID,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAAC;CAC1F;;AAID,qBAAa,iBAAkB,SAAQ,sBAGpC;CAAG;AAkQN,eAAO,MAAM,qBAAqB,0EAyCjC,CAAC"}

package/dist/lib/workspace-detector.js

@@ -0,0 +1,118 @@
+import { Context, Data, Effect, Layer, Array as Arr, Option, pipe, Schema } from 'effect';
+import { FileSystem, Path } from '@effect/platform';
+import fg from 'fast-glob';
+import YAML from 'yaml';
+import { WorkspaceNotFoundError } from './errors.js';
+const JsonRecord = Schema.parseJson(Schema.Record({ key: Schema.String, value: Schema.Unknown }));
+// ─── Tag ─────────────────────────────────────────────────────────────────────
+export class WorkspaceDetector extends Context.Tag('WorkspaceDetector')() {
+}
+// ─── Internal errors ──────────────────────────────────────────────────────────
+class GlobError extends Data.TaggedError('GlobError') {
+}
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+const collectExportsStrings = (value) => {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return pipe(value, Arr.flatMap(collectExportsStrings));
+    if (value !== null && typeof value === 'object') {
+        return pipe(Object.values(value), Arr.flatMap(collectExportsStrings));
+    }
+    return [];
+};
+const extractEntryPoints = (pkg) => {
+    if (pkg['exports'] !== undefined) {
+        return pipe(collectExportsStrings(pkg['exports']), Arr.dedupe);
+    }
+    return pipe(['main', 'module', 'types'], Arr.filterMap((field) => {
+        const val = pkg[field];
+        return typeof val === 'string' ? Option.some(val) : Option.none();
+    }), Arr.dedupe);
+};
+const readPackageInfo = (fs, pathSvc, pkgDir) => {
+    const pkgPath = pathSvc.join(pkgDir, 'package.json');
+    return pipe(fs.exists(pkgPath), Effect.flatMap((exists) => {
+        if (!exists)
+            return Effect.succeed(null);
+        return pipe(fs.readFileString(pkgPath, 'utf-8'), Effect.flatMap((contents) => Schema.decodeUnknown(JsonRecord)(contents)), Effect.map((parsed) => {
+            const name = typeof parsed['name'] === 'string' ? parsed['name'] : pathSvc.basename(pkgDir);
+            const entryPoints = extractEntryPoints(parsed);
+            return { name, root: pkgDir, entryPoints: [...entryPoints] };
+        }), Effect.catchAll(() => Effect.succeed(null)));
+    }), Effect.catchAll(() => Effect.succeed(null)));
+};
+const resolveWorkspaceGlobs = (pathSvc, root, globs) => pipe(Effect.tryPromise({
+    try: () => fg(pipe(globs, Arr.map((g) => `${g}/package.json`)), { cwd: root, absolute: true, onlyFiles: true }),
+    catch: (cause) => new GlobError({ cause }),
+}), Effect.map((files) => pipe(files, Arr.map((p) => pathSvc.dirname(p)))));
+const readPkgDirs = (fs, pathSvc, root, globs) => pipe(resolveWorkspaceGlobs(pathSvc, root, globs), Effect.flatMap((dirs) => Effect.all(pipe(dirs, Arr.map((d) => readPackageInfo(fs, pathSvc, d))))), Effect.map((infos) => pipe(infos, Arr.filter((p) => p !== null))), Effect.catchTag('GlobError', () => Effect.succeed([])));
+// ─── Workspace detection strategies ─────────────────────────────────────────
+const extractWorkspaceGlobs = (workspaces) => {
+    if (Array.isArray(workspaces)) {
+        return pipe(workspaces, Arr.filter((g) => typeof g === 'string'));
+    }
+    if (typeof workspaces === 'object' && workspaces !== null) {
+        const obj = workspaces;
+        if (Array.isArray(obj.packages)) {
+            return pipe(obj.packages, Arr.filter((g) => typeof g === 'string'));
+        }
+    }
+    return [];
+};
+const detectPnpm = (fs, pathSvc, cwd) => pipe(fs.exists(pathSvc.join(cwd, 'pnpm-workspace.yaml')), Effect.orDie, Effect.flatMap((exists) => exists
+    ? pipe(fs.readFileString(pathSvc.join(cwd, 'pnpm-workspace.yaml'), 'utf-8'), Effect.orDie, Effect.map((raw) => {
+        const parsed = YAML.parse(raw);
+        return parsed?.packages ?? [];
+    }), Effect.flatMap((globs) => readPkgDirs(fs, pathSvc, cwd, globs)), Effect.map((packages) => ({
+        type: 'pnpm',
+        root: cwd,
+        packages,
+    })))
+    : Effect.fail(new WorkspaceNotFoundError({ cwd }))));
+const detectNpmWorkspaces = (fs, pathSvc, cwd, rootPkg) => {
+    const globs = extractWorkspaceGlobs(rootPkg['workspaces']);
+    return globs.length > 0
+        ? pipe(readPkgDirs(fs, pathSvc, cwd, globs), Effect.map((packages) => ({
+            type: 'npm',
+            root: cwd,
+            packages,
+        })))
+        : Effect.fail(new WorkspaceNotFoundError({ cwd }));
+};
+const detectNx = (fs, pathSvc, cwd) => pipe(fs.exists(pathSvc.join(cwd, 'nx.json')), Effect.orDie, Effect.flatMap((exists) => exists
+    ? pipe(readPkgDirs(fs, pathSvc, cwd, ['packages/*', 'libs/*', 'apps/*']), Effect.flatMap((packages) => packages.length > 0
+        ? Effect.succeed({
+            type: 'nx',
+            root: cwd,
+            packages,
+        })
+        : Effect.fail(new WorkspaceNotFoundError({ cwd }))))
+    : Effect.fail(new WorkspaceNotFoundError({ cwd }))));
+const detectTurbo = (fs, pathSvc, cwd) => pipe(fs.exists(pathSvc.join(cwd, 'turbo.json')), Effect.orDie, Effect.flatMap((exists) => exists
+    ? pipe(readPkgDirs(fs, pathSvc, cwd, ['packages/*', 'apps/*']), Effect.flatMap((packages) => packages.length > 0
+        ? Effect.succeed({
+            type: 'turborepo',
+            root: cwd,
+            packages,
+        })
+        : Effect.fail(new WorkspaceNotFoundError({ cwd }))))
+    : Effect.fail(new WorkspaceNotFoundError({ cwd }))));
+const detectSingle = (fs, pathSvc, cwd) => pipe(readPackageInfo(fs, pathSvc, cwd), Effect.flatMap((pkg) => pkg !== null
+    ? Effect.succeed({
+        type: 'single',
+        root: cwd,
+        packages: [pkg],
+    })
+    : Effect.fail(new WorkspaceNotFoundError({ cwd }))));
+// ─── Live implementation ──────────────────────────────────────────────────────
+export const WorkspaceDetectorLive = Layer.effect(WorkspaceDetector, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathSvc = yield* Path.Path;
+    const detect = (cwd) => pipe(detectPnpm(fs, pathSvc, cwd), Effect.catchTag('WorkspaceNotFoundError', () => pipe(fs.exists(pathSvc.join(cwd, 'package.json')), Effect.orDie, Effect.flatMap((hasRootPkg) => {
+        if (!hasRootPkg)
+            return Effect.fail(new WorkspaceNotFoundError({ cwd }));
+        return pipe(fs.readFileString(pathSvc.join(cwd, 'package.json'), 'utf-8'), Effect.orDie, Effect.flatMap((raw) => pipe(Schema.decodeUnknown(JsonRecord)(raw), Effect.mapError(() => new WorkspaceNotFoundError({ cwd })))), Effect.flatMap((rootPkg) => pipe(detectNpmWorkspaces(fs, pathSvc, cwd, rootPkg), Effect.catchTag('WorkspaceNotFoundError', () => detectNx(fs, pathSvc, cwd)), Effect.catchTag('WorkspaceNotFoundError', () => detectTurbo(fs, pathSvc, cwd)), Effect.catchTag('WorkspaceNotFoundError', () => detectSingle(fs, pathSvc, cwd)))));
+    }))));
+    return { detect };
+}));

package/dist/test-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../src/test-setup.ts"],"names":[],"mappings":""}

package/dist/test-setup.js

@@ -0,0 +1,2 @@
+import { addEqualityTesters } from '@effect/vitest';
+addEqualityTesters();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@wolfcola/dead-export-finder",
+  "version": "0.0.0-beta-20260513233134",
+  "type": "module",
+  "private": false,
+  "description": "Find dead exports across monorepo package boundaries",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ryanbas21/devtools.git",
+    "directory": "packages/dead-export-finder"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "dead-export-finder": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "effect": "^3.21.1",
+    "@effect/cli": "^0.75.1",
+    "@effect/platform": "^0.96.0",
+    "@effect/platform-node": "^0.106.0",
+    "oxc-parser": "^0.72.0",
+    "fast-glob": "^3.3.3",
+    "ignore": "^7.0.4",
+    "yaml": "^2.7.1"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^0.29.0",
+    "vitest": "^3.2.0",
+    "vite": "^7.3.2",
+    "typescript": "5.8.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json",
+    "lint": "eslint .",
+    "test": "vitest run"
+  }
+}