tdepend 0.2.0 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Mohamed Saad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,167 +1,263 @@
-# TDepend
-
-TDepend is a JDepend-inspired dependency analysis tool for the TypeScript ecosystem.
+# tdepend
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Features
+tdepend's goal is to make TypeScript architecture contracts executable. Version 0.3 delivers the foundation those contracts need: an import graph that matches the TypeScript compiler.
+
+It finds your projects, workspace packages and `tsconfig` files, then resolves every import through TypeScript's own resolver. For each import it records:
 
-- 📊 Compute architectural metrics (Ca, Ce, Abstractness, Instability, Distance)
-- 🔄 Detect circular dependencies
-- 📏 Threshold-based quality gates for CI/CD
-- 🎯 Scoped analysis (module/namespace/class)
-- ⚙️ Fully config-driven with sensible defaults
-- 🚀 CI mode with JSON output
-- 📦 Zero runtime dependencies for analysis
+- where it is, by file, line and column;
+- what form it takes, such as a static import, a `require` or a type-only import;
+- what it resolves to, in one of ten classes;
+- whether it really loads its target at runtime, or the compiler erases it.
+
+Architecture rules, metrics, cycles and baselines are not in this version. See [Migrating from 0.2](#migrating-from-02).
 
 ## Installation
 
+tdepend needs Node 22.12 or later.
+
 ```bash
-npm install -g tdepend
+npm install --save-dev tdepend
 # or
-pnpm add -g tdepend
-# or
-yarn global add tdepend
+pnpm add --save-dev tdepend
 ```
 
-## Quick Start
-
-### CLI Usage
+## Usage
 
 ```bash
-# Analyze your TypeScript project
-tdepend analyze
+tdepend analyze                     # report on the current directory
+tdepend analyze --root path/to/repo # report on another directory
+tdepend explain src/main.tsx        # show every import in one file
+```
 
-# Use custom config file
-tdepend analyze --config my-config.json
+Both commands take `--root <dir>` and `--config <path>`. `tdepend --version` prints the version and `tdepend --help` lists the commands.
 
-# CI mode with JSON output
-tdepend analyze --ci
+tdepend reads the checkout as it is, so it works before a build and usually before `pnpm install`. The exception is a `tsconfig` whose `extends` names a package or a generated file. That target must exist, or tdepend exits 2 and names the config. tdepend never writes to the analysed repo unless you point `--export` there.
 
-# Export full analysis to JSON file
-tdepend analyze --export analysis-result.json
-```
+### `tdepend analyze`
 
-### Library Usage
+| Option | Meaning |
+|---|---|
+| `-f, --format <text\|json>` | Output format, `text` by default |
+| `-e, --export <path>` | Also write the full result to a JSON file |
+| `--strict-resolution` | Exit 2 when any import is unresolved |
 
-TDepend can also be used programmatically as a library:
+The exit code is 0, or 2 on a config or parse error, or when the analysis root doesn't exist. With `--strict-resolution` it is also 2 when an import is unresolved, which makes that flag the one gate this version offers for CI.
 
-```typescript
-import { analyze, exportToFile } from 'tdepend';
+The text report looks like this:
 
-// Analyze a project
-const result = await analyze({
-  rootDir: 'src',
-  include: ['src/**/*.ts'],
-  failOnCycle: true
-});
+```text
+Files: 6
+Import sites: 10
+Edges: 2
 
-console.log(`Analyzed ${result.modules.length} modules`);
-console.log(`Found ${result.cycles.length} cycles`);
+Sites by class:
+  builtin: 1
+  asset: 2
+  virtual: 1
+  internal: 2
+  workspace: 0
+  excluded: 2
+  external: 0
+  ignored: 0
+  unsupported: 0
+  unresolved: 2
 
-// Export results to JSON
-await exportToFile(result, 'architecture-snapshot.json');
+Unresolved imports (2):
+  src/main.tsx:6  ./missing
+  src/main.tsx:9  left-pad
 
-// Access detailed metrics
-for (const metric of result.metrics) {
-  if (metric.distance > 0.8) {
-    console.log(`${metric.filePath}: D=${metric.distance.toFixed(2)}`);
-  }
-}
+Ignored (gitignored targets): 0
+
+Unsupported imports: 0
+
+Self-imports: 0
+Files outside every tsconfig: 2
 ```
 
-#### API Reference
+**Files** is the analysis set. **Import sites** counts every import statement or call. **Edges** counts the file pairs connected by at least one site.
 
-**Main Functions:**
-- `analyze(options?)` - Analyze a TypeScript project
-- `analyzeWithConfig(config)` - Analyze using a full config object
-- `exportToFile(result, filePath, options?)` - Export analysis to JSON file
-- `exportToJson(result, options?)` - Convert analysis to JSON string
+Every site gets exactly one class:
 
-**Core Building Blocks:**
-- `DependencyGraph` - Graph data structure
-- `detectCycles(graph)` - Cycle detection
-- `computeAllMetrics(graph, modules, cycles)` - Metric computation
-- `parseProject(files)` - Parse TypeScript files
-- `scanFiles(config)` - Scan files matching patterns
+| Class | Meaning | Adds a graph edge |
+|---|---|---|
+| `builtin` | A Node built-in; `fs` and `node:fs` count as the same module | No |
+| `virtual` | A `virtual:` or `~icons/` module, or a `resolve.virtual` pattern | No |
+| `asset` | A stylesheet, image, font, JSON or Markdown file, or anything with a `?query` | No |
+| `internal` | A file in the analysis set, in the same package | Yes |
+| `workspace` | A file in the analysis set, in a different workspace package | Yes |
+| `excluded` | A repo file outside the analysis set, such as a test or generated file | No |
+| `external` | A package from `node_modules`, or one declared in `package.json` but not installed | No |
+| `ignored` | An unresolved import that matches `resolve.ignoreUnresolved`, or whose target is gitignored | No |
+| `unsupported` | A form tdepend can't follow, such as `import(name)`, a shadowed `require`, or a JSDoc import type | No |
+| `unresolved` | None of the above; this is usually a broken import | No |
 
-See the [examples](./examples) directory for more usage patterns.
+The report also counts self-imports and files that no `tsconfig` covers. When a package is declared but missing, it adds a line asking whether `node_modules` is installed. Discovery warnings, such as a compiler option TypeScript 5.9 doesn't know, are listed at the end.
 
-## Configuration
+### `tdepend explain <file>`
 
-TDepend looks for `tdepend.config.json` in the current directory.
+`explain` is the debugging tool. It prints one row per import: position, kind, class, target and the runtime verdict with its reason.
 
-### Config File Example
+```text
+1:8  side-effect  internal  '@/components/button' -> src/components/button.tsx  loads (retained): a side-effect import is evaluated and every compiler keeps it
+3:8  side-effect  asset  './styles.css' -> -  loads (retained): a side-effect import is evaluated and every compiler keeps it
+7:27  static  excluded  './routeTree.gen' -> src/routeTree.gen.ts  loads (retained): at least one binding is used as a value
+10:16  static  builtin  'node:fs' -> node:fs  loads (retained): at least one binding is used as a value
+```
+
+The verdict rule is conservative: an import loads its target unless `tsc`, esbuild and swc would all drop it. A reported runtime edge may therefore be one a single compiler would erase, but an import reported as erased is erased by every listed compiler.
+
+The word in brackets is the kind of evidence. `syntax` means the form alone decides, as with `import type`. `usage` means no binding is used as a value. `retained` means a compiler keeps the import.
+
+### JSON export
+
+`--export <path>` and `--format json` write the same versioned document. It has no timestamp and every list is sorted, so two runs on the same inputs produce byte-identical output.
 
 ```json
 {
-  "rootDir": "src",
-  "include": ["src/**/*.ts", "src/**/*.tsx"],
-  "exclude": ["**/*.test.ts", "**/*.spec.ts", "dist"],
-  "metrics": {
-    "enabled": ["coupling", "abstractness", "distance", "cycles"],
-    "thresholds": {
-      "distance": 0.6
+  "version": 1,
+  "files": ["src/main.ts", "src/util.ts"],
+  "edges": [
+    { "from": "src/main.ts", "to": "src/util.ts", "runtime": true, "mapped": false, "kinds": ["static"] }
+  ],
+  "sites": [
+    {
+      "file": "src/main.ts",
+      "specifier": "./util",
+      "line": 1,
+      "column": 22,
+      "kind": "static",
+      "form": "declaration",
+      "deferred": false,
+      "unsupported": null,
+      "loadsTarget": true,
+      "loadsTargetBy": "retained",
+      "class": "internal",
+      "reason": null,
+      "target": { "file": "src/util.ts" },
+      "mapped": null,
+      "requested": null
     }
-  },
-  "analysis": {
-    "target": null,
-    "value": null
-  },
-  "ci": {
-    "failOnThreshold": true,
-    "outputFormat": "json"
-  }
+  ],
+  "report": { "...": "class counts, unresolved, ignored and unsupported sites, warnings" }
 }
 ```
 
-### Configuration Options
+Paths are relative to the analysis root and use `/` on every platform. Lines and columns start at 1, and the column points at the opening quote of the specifier. An edge is `runtime` when at least one of its sites loads the target, and `mapped` when a declared output path such as `dist/index.d.ts` was mapped back to its source file.
 
-- **rootDir**: Root directory for analysis (default: `"src"`)
-- **include**: Glob patterns for files to include (default: `["src/**/*.ts", "src/**/*.tsx"]`)
-- **exclude**: Glob patterns for files to exclude (default: `["**/*.test.ts", "**/*.spec.ts", "dist"]`)
-- **metrics.enabled**: Array of metrics to compute (options: `"coupling"`, `"abstractness"`, `"distance"`, `"cycles"`)
-- **metrics.thresholds.distance**: Maximum allowed distance from main sequence (default: `0.6`)
-- **analysis.target**: Scope analysis to `"module"`, `"class"`, or `"namespace"` (default: `null`)
-- **analysis.value**: Value for the target scope (default: `null`)
-- **ci.failOnThreshold**: Exit with code 1 on threshold violations (default: `true`)
-- **ci.failOnCycle**: Exit with code 1 when cycles are detected (default: `false`)
-- **ci.outputFormat**: Output format - `"console"` or `"json"` (default: `"console"`)
+## Library API
 
-## Development
+The package exports four functions, plus the types of the values they return.
 
-```bash
-# Install dependencies
-pnpm install
+```ts
+import { analyze, explainFile, exportToFile, toSerializable } from 'tdepend';
+
+const result = await analyze({ root: '.' });
 
-# Build
-pnpm run build
+const { edges, report } = toSerializable(result);
+console.log(`${edges.length} edges, ${report.unresolved.length} unresolved imports`);
 
-# Run tests
-pnpm test
+await exportToFile(result, 'graph.json');
 
-# Format code
-pnpm format
+const rows = await explainFile({ root: '.', file: 'src/main.tsx' });
+for (const row of rows) {
+  console.log(row.specifier, row.class, row.loadsTarget);
+}
 ```
 
-## Project Structure
+- `analyze(options?)` runs the whole pipeline. Its options are `root`, `config` and `typeOnly`.
+- `explainFile(options)` takes the same options plus `file`, and returns one row per import.
+- `toSerializable(result)` returns the JSON document above.
+- `exportToFile(result, path)` writes that document to a file.
+
+## Configuration
+
+tdepend looks for `tdepend.config.json` in the analysis root, or uses `--config <path>`. A config is optional. These are the keys that work in 0.3, with their defaults:
+
+```json
+{
+  "root": ".",
+  "include": [],
+  "exclude": [],
+  "typeOnly": "usage",
+  "compilers": ["tsc", "esbuild", "swc"],
+  "resolve": { "aliases": {}, "virtual": [], "ignoreUnresolved": [] }
+}
+```
+
+- **`root`** is the analysis root, relative to `--root` or the working directory.
+- **`include`** replaces discovery when it isn't empty. It takes root-relative globs, and `exclude` still applies.
+- **`exclude`** adds to the built-in skips below. An entry starting with `!` removes an earlier pattern, so `"!**/public/**"` keeps `public/`.
+- **`typeOnly`** is `usage` or `syntax`. With `syntax`, every static import counts as loading its target, however its bindings are used.
+- **`compilers`** names the compilers you really use. In 0.3 it only changes empty `import {} from` statements, which `tsc` erases and swc keeps.
+- **`resolve.aliases`** is for aliases that exist only in a bundler config, as a prefix map relative to the importing file's project, such as `{ "@/": "src/" }`. Aliases in `tsconfig` `paths` need no config.
+- **`resolve.virtual`** lists extra patterns to treat as `virtual`.
+- **`resolve.ignoreUnresolved`** lists unresolved imports to class as `ignored`.
+
+The built-in skips are test and spec files, `__tests__`, stories, declaration files, `*.min.js`, `public` and a root `e2e` folder. Gitignored files are skipped too. Directories named `node_modules`, `dist`, `build`, `out` and `coverage`, and dot directories such as `.storybook`, are never walked, so `include` can't reach them. A `tsconfig` that lists a file in a dot directory still brings that file in.
+
+`exclude` also applies to `tsconfig` files, so a deliberately broken one under a fixtures folder can be left out.
+
+The keys `presets` and `metrics.abstractness` are accepted and have no effect yet. An unknown key exits 2, and so do `rules`, `components`, `baseline` and `metrics.thresholds`, which belong to later releases.
+
+## Migrating from 0.2
+
+Version 0.3 is a rewrite, with no compatibility layer. The old graph missed aliases, re-exports, dynamic imports and workspace packages, so it was replaced rather than patched.
+
+- **Metrics and cycles are gone for now.** 0.3 reports the graph only. Coupling metrics, cycles and rules arrive in 0.4, through a new `check` command with baselines. Comparing a pull request against its base arrives in 0.5.
+- **Removed exports:** `analyzeWithConfig`, `exportToJson`, `DependencyGraph`, `detectCycles`, `computeAllMetrics`, `parseProject` and `scanFiles`. The public API is now the four functions above.
+- **Removed CLI option:** `--ci`. Use `--format json` for machine output and `--strict-resolution` to fail a build.
+- **Removed config keys:** `rootDir`, `ci`, `analysis` and `metrics.enabled`. `metrics.thresholds` returns in 0.4.
+- **Old configs are rejected.** A config with `rootDir`, `ci` or `analysis` exits 2 with this message:
+
+  ```text
+  This looks like a tdepend 0.2 config. See 'Migrating from 0.2' in the README.
+  ```
+
+  Start again from the keys in [Configuration](#configuration).
+- **Node 22.12 or later** is now required.
+
+## Support levels
+
+| Level | Layouts |
+|---|---|
+| **Supported**, covered by a fixture | NestJS with CommonJS or NodeNext, NestJS monorepos using `paths`, Next.js apps, Vite with TanStack Router, TanStack Start, Express in CommonJS JavaScript, Fastify in ESM, plain Node libraries, feature-based frontends, pnpm and npm workspaces including unbuilt and bundler-built packages, several apps without a workspace config, nested projects |
+| **Configured manually** | Aliases that exist only in a bundler config, through `resolve.aliases`; unusual layouts, through `include` |
+| **Experimental** | Yarn workspaces without Plug'n'Play, which use the same `package.json` form as npm but have no fixture of their own |
+| **Unsupported** | Vue, Svelte and Astro single-file components, Yarn Plug'n'Play, non-literal dynamic loading |
+
+## Development
+
+```bash
+pnpm install
+pnpm run clean      # remove dist
+pnpm run build      # clean, then compile
+pnpm test           # run the test suite
+pnpm run typecheck  # check the sources and the tests
 ```
+
+## Project structure
+
+```text
 src/
-  api/           # Public library API
-  cli/           # CLI entry point
-  config/        # Configuration loading and validation
-  parser/        # TypeScript file parsing
-  graph/         # Dependency graph and cycle detection
-  metrics/       # Metric computation
-  analysis/      # Reporting
-  utils/         # Utilities
-  tests/         # Test files
-  types/         # Type definitions
-  index.ts       # Library entry point
-
-dist/            # Compiled output
-examples/        # Usage examples
+  api/        analyze, explainFile, exportToFile, toSerializable
+  cli/        command line entry point
+  config/     config schema and loading
+  files/      the analysis set
+  graph/      the file graph and resolution report
+  output/     the text report
+  parser/     import sites and runtime-load classification
+  project/    projects, workspace packages, tsconfigs, gitignore rules
+  resolver/   TypeScript resolution, workspace host, classification
+  tests/      tests and fixtures
+  types/      public result types
+  fs.ts       file system port
+  errors.ts   errors that exit 2
+  index.ts    library entry point
+scripts/      regenerates the compiler fixture expectations
 ```
 
 ## License
-MIT
+
+[MIT](LICENSE)

package/dist/api/analyze.d.ts

@@ -1,75 +1,15 @@
-import type { TDependConfig } from '../config/schema';
 import type { AnalysisResult } from '../types/api';
-/**
- * Options for the analyze() function.
- * These options are merged with config file settings (if any).
- */
 export interface AnalyzeOptions {
-    /** Root directory to analyze (default: 'src') */
-    rootDir?: string;
-    /** Glob patterns for files to include (default: ['src/**\/*.ts', 'src/**\/*.tsx']) */
-    include?: string[];
-    /** Glob patterns for files to exclude (default: ['**\/*.test.ts', '**\/*.spec.ts', 'dist']) */
-    exclude?: string[];
-    /** Path to config file. If not provided, looks for tdepend.config.json */
+    /** Root directory to analyse. Defaults to the current working directory. */
+    root?: string;
+    /** Path to the tdepend config file. Discovered under the root when omitted. */
     config?: string;
-    /** Fail analysis if cycles are detected (default: false) */
-    failOnCycle?: boolean;
-    /** Fail analysis if distance threshold is exceeded (default: true) */
-    failOnThreshold?: boolean;
+    /** Overrides the config's type-only detection for this run. */
+    typeOnly?: 'usage' | 'syntax';
 }
 /**
- * Analyzes a TypeScript project and returns complete dependency analysis.
- *
- * This is the main entry point for programmatic usage of tdepend.
- * It orchestrates the entire analysis pipeline:
- * 1. Load and merge configuration
- * 2. Scan files matching include/exclude patterns
- * 3. Parse TypeScript modules
- * 4. Build dependency graph
- * 5. Detect cycles
- * 6. Compute metrics (coupling, abstractness, instability, distance)
- * 7. Generate report with violations
- *
- * @param options - Analysis options (merged with config file if present)
- * @returns Complete analysis result with modules, graph, metrics, and report
- *
- * @example
- * ```typescript
- * import { analyze } from 'tdepend';
- *
- * const result = await analyze({
- *   rootDir: 'src',
- *   include: ['src/**\/*.ts'],
- *   failOnCycle: true
- * });
- *
- * console.log(`Analyzed ${result.modules.length} modules`);
- * console.log(`Found ${result.cycles.length} cycles`);
- * ```
+ * Runs the whole pipeline once: discover projects, packages and tsconfigs,
+ * collect the analysis set, parse every file's import sites, resolve each site
+ * through TypeScript with a workspace host, and build the file graph.
  */
 export declare function analyze(options?: AnalyzeOptions): Promise<AnalysisResult>;
-/**
- * Analyzes a TypeScript project using a provided configuration object.
- *
- * This is useful when you want full control over the configuration
- * without loading from a file or merging with defaults.
- *
- * @param config - Complete TDependConfig object
- * @returns Complete analysis result with modules, graph, metrics, and report
- *
- * @example
- * ```typescript
- * import { analyzeWithConfig, defaultConfig } from 'tdepend';
- *
- * const result = await analyzeWithConfig({
- *   ...defaultConfig,
- *   rootDir: 'src',
- *   ci: {
- *     ...defaultConfig.ci,
- *     failOnCycle: true
- *   }
- * });
- * ```
- */
-export declare function analyzeWithConfig(config: TDependConfig): Promise<AnalysisResult>;

package/dist/api/analyze.js

@@ -1,120 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyze = analyze;
-exports.analyzeWithConfig = analyzeWithConfig;
+const node_path_1 = require("node:path");
 const loadConfig_1 = require("../config/loadConfig");
-const fileScanner_1 = require("../parser/fileScanner");
-const tsParser_1 = require("../parser/tsParser");
-const dependencyGraph_1 = require("../graph/dependencyGraph");
-const cycleDetector_1 = require("../graph/cycleDetector");
-const metrics_1 = require("../metrics");
-const reporter_1 = require("../analysis/reporter");
-const deepMerge_1 = require("../utils/deepMerge");
+const errors_1 = require("../errors");
+const collectFiles_1 = require("../files/collectFiles");
+const fs_1 = require("../fs");
+const buildFileGraph_1 = require("../graph/buildFileGraph");
+const discoverProject_1 = require("../project/discoverProject");
+const createResolver_1 = require("../resolver/createResolver");
 /**
- * Analyzes a TypeScript project and returns complete dependency analysis.
- *
- * This is the main entry point for programmatic usage of tdepend.
- * It orchestrates the entire analysis pipeline:
- * 1. Load and merge configuration
- * 2. Scan files matching include/exclude patterns
- * 3. Parse TypeScript modules
- * 4. Build dependency graph
- * 5. Detect cycles
- * 6. Compute metrics (coupling, abstractness, instability, distance)
- * 7. Generate report with violations
- *
- * @param options - Analysis options (merged with config file if present)
- * @returns Complete analysis result with modules, graph, metrics, and report
- *
- * @example
- * ```typescript
- * import { analyze } from 'tdepend';
- *
- * const result = await analyze({
- *   rootDir: 'src',
- *   include: ['src/**\/*.ts'],
- *   failOnCycle: true
- * });
- *
- * console.log(`Analyzed ${result.modules.length} modules`);
- * console.log(`Found ${result.cycles.length} cycles`);
- * ```
+ * Runs the whole pipeline once: discover projects, packages and tsconfigs,
+ * collect the analysis set, parse every file's import sites, resolve each site
+ * through TypeScript with a workspace host, and build the file graph.
  */
 async function analyze(options = {}) {
-    // Load config from file (or use defaults if no file exists)
-    const baseConfig = options.config ? (0, loadConfig_1.loadConfig)(options.config) : (0, loadConfig_1.loadConfig)();
-    // Create partial config from options
-    const optionsConfig = {};
-    if (options.rootDir !== undefined) {
-        optionsConfig.rootDir = options.rootDir;
+    const baseDir = (0, node_path_1.resolve)(options.root ?? process.cwd());
+    const { config } = (0, loadConfig_1.loadConfig)({ cwd: baseDir, configPath: options.config });
+    const rootDir = config.root === '.' ? baseDir : (0, node_path_1.resolve)(baseDir, config.root);
+    if (!(0, fs_1.isDir)((0, fs_1.nodeFileSystem)(), rootDir)) {
+        throw new errors_1.ConfigError(`Root directory not found: ${rootDir}`);
     }
-    if (options.include !== undefined) {
-        optionsConfig.include = options.include;
-    }
-    if (options.exclude !== undefined) {
-        optionsConfig.exclude = options.exclude;
-    }
-    if (options.failOnCycle !== undefined || options.failOnThreshold !== undefined) {
-        optionsConfig.ci = {
-            ...baseConfig.ci,
-            ...(options.failOnCycle !== undefined && { failOnCycle: options.failOnCycle }),
-            ...(options.failOnThreshold !== undefined && { failOnThreshold: options.failOnThreshold }),
-        };
-    }
-    // Merge configs (options override file config)
-    const config = (0, deepMerge_1.deepMerge)(baseConfig, optionsConfig);
-    // Run analysis pipeline
-    const files = await (0, fileScanner_1.scanFiles)(config);
-    const modules = (0, tsParser_1.parseProject)(files);
-    const graph = new dependencyGraph_1.DependencyGraph(modules);
-    const cycles = (0, cycleDetector_1.detectCycles)(graph);
-    const metrics = (0, metrics_1.computeAllMetrics)(graph, modules, cycles);
-    const report = (0, reporter_1.generateReport)(modules, metrics, cycles, config);
-    return {
-        modules,
-        graph,
-        cycles,
-        metrics,
-        report,
-        config,
-    };
-}
-/**
- * Analyzes a TypeScript project using a provided configuration object.
- *
- * This is useful when you want full control over the configuration
- * without loading from a file or merging with defaults.
- *
- * @param config - Complete TDependConfig object
- * @returns Complete analysis result with modules, graph, metrics, and report
- *
- * @example
- * ```typescript
- * import { analyzeWithConfig, defaultConfig } from 'tdepend';
- *
- * const result = await analyzeWithConfig({
- *   ...defaultConfig,
- *   rootDir: 'src',
- *   ci: {
- *     ...defaultConfig.ci,
- *     failOnCycle: true
- *   }
- * });
- * ```
- */
-async function analyzeWithConfig(config) {
-    const files = await (0, fileScanner_1.scanFiles)(config);
-    const modules = (0, tsParser_1.parseProject)(files);
-    const graph = new dependencyGraph_1.DependencyGraph(modules);
-    const cycles = (0, cycleDetector_1.detectCycles)(graph);
-    const metrics = (0, metrics_1.computeAllMetrics)(graph, modules, cycles);
-    const report = (0, reporter_1.generateReport)(modules, metrics, cycles, config);
+    const ctx = (0, discoverProject_1.discoverProject)(rootDir, {
+        isExcluded: (0, collectFiles_1.createExcludeMatcher)(collectFiles_1.DEFAULT_SKIPS, config.exclude),
+        isConfigExcluded: (0, collectFiles_1.createExcludeMatcher)([], config.exclude),
+    });
+    const files = (0, collectFiles_1.collectFiles)(ctx, {
+        include: config.include,
+        exclude: config.exclude,
+        presetSkips: collectFiles_1.DEFAULT_SKIPS,
+    });
+    const resolver = (0, createResolver_1.createResolver)(ctx, new Set(files.files), config.resolve);
+    const built = (0, buildFileGraph_1.buildFileGraph)(ctx, files, resolver, options.typeOnly ?? config.typeOnly, {
+        compilers: config.compilers,
+    });
     return {
-        modules,
-        graph,
-        cycles,
-        metrics,
-        report,
+        ctx,
+        files,
+        graph: built.graph,
+        sites: built.sites,
+        report: built.report,
         config,
     };
 }