entkapp 5.2.4 → 5.3.0

package/README.md

@@ -1,75 +1,68 @@
-# 🕸️ entkapp Ultimate v5.2.4
+# 🕸️ entkapp Ultimate v5.3.0
 
-> **The Ultimate Enterprise Codebase Janitor.** Faster than Knip with OXC integration, type-aware analysis, and automated structural healing. Fully standalone - solving what Knip cannot.
+> **The Ultimate Enterprise Codebase Janitor.** High-speed OXC integration, type-aware analysis, and automated structural healing. Fully standalone architectural orchestrator.
 
 ![Version](https://img.shields.io/npm/v/entkapp) ![License](https://img.shields.io/badge/license-Apache--2.0-green.svg) ![Performance](https://img.shields.io/badge/performance-OXC--Inside-blueviolet.svg)
 
 ---
 
-`entkapp` ist eine next-generation Engine zur statischen Code-Analyse, die die Stabilität der bewährten Version 7 mit den Hochleistungs-Features der Version 9 kombiniert. Sie findet ungenutzte Dateien, tote Exports, zirkuläre Abhängigkeiten und Sicherheitsrisiken schneller als jedes andere Tool im Ökosystem.
+`entkapp` is a next-generation static code analysis engine. It identifies unused files, dead exports, circular dependencies, and security risks faster than any other tool in the ecosystem..
 
-## 🚀 Warum entkapp?
+## 🚀 Why entkapp?
 
-*   **⚡ Blazing Fast:** Nutzt den Rust-basierten `oxc-parser` für extrem schnelle AST-Traversierung, kombiniert mit der TypeScript Compiler API für tiefe semantische Analysen.
-*   **🔌 Massives Plugin-System:** Über 80+ integrierte Plugins (React, Vue, Svelte, Angular, Next.js, Nuxt, SvelteKit, Astro, Vite, Webpack, Turbo, Nx, Tailwind, ESLint, Prettier und viele mehr).
-*   **💀 True Dead Code Detection:** Fortschrittliche graphbasierte Analyse zur Identifizierung von wirklich verwaistem Code.
-*   **🔄 Circular Dependency Detection:** Hochperformante Erkennung von zirkulären Abhängigkeiten mittels Tarjan's Algorithmus.
-*   **🔐 Secrets Scanning:** Automatische Erkennung von hartkodierten API-Keys, Tokens und Anmeldedaten.
-*   **🛠️ Automated Structural Healing:** Repariert Abhängigkeitsprobleme und strukturelle Fehler automatisch mit Git-basiertem Rollback-Schutz.
+*   **⚡ Blazing Fast:** Leverages the Rust-based `oxc-parser` for ultra-fast AST traversal, combined with the TypeScript Compiler API for deep semantic analysis.
+*   **🔌 Massive Plugin System:** Over 98 built-in plugins (React, Vue, Svelte, Angular, Next.js, Nuxt, SvelteKit, Astro, Vite, Webpack, Turbo, Nx, Tailwind, ESLint, Prettier, and many more).
+*   **💀 True Dead Code Detection:** Advanced graph-based analysis to identify genuinely orphaned code.
+*   **🔄 Circular Dependency Detection:** High-performance detection of circular dependencies using Tarjan's algorithm.
+*   **🔐 Secrets Scanning:** Automatic detection of hardcoded API keys, tokens, and credentials.
+*   **🛠️ Automated Structural Healing:** Automatically fixes dependency issues and structural errors with Git-based rollback protection.
 
 ## 📦 Installation
 
 ```bash
-# Direkt ausführen ohne Installation (empfohlen)
+# Run directly without installation (recommended)
 npx entkapp
 
-# Oder global installieren
+# Or install it globally
 npm install -g entkapp
 ```
 
-## 🛠️ Nutzung
+## 🛠️ Usage
 
-### Interaktiver Modus (Standard)
-Startet den interaktiven Analyse- und Scaffolding-Workflow:
+### Interactive Mode (Default)
+Starts the interactive analysis:
 ```bash
-npx entkapp
+npx entkapp -r
 ```
 
-### Headless Analyse-Modus
-Ideal für CI/CD-Pipelines. Führt die Analyse ohne Prompts durch und gibt JSON aus:
+### Headless Analysis Mode
+Ideal for CI/CD pipelines. Performs analysis without prompts and outputs JSON:
 ```bash
 npx entkapp --analyze
 ```
 
-### Auto-Fix Modus
-Behebt automatisch Abhängigkeitskonflikte und strukturelle Probleme:
+### Auto-Fix Mode
+Automatically resolves dependency conflicts and structural issues:
 ```bash
 npx entkapp --fix
 ```
 
-### Zusätzliche Optionen
+### Additional Options
 ```bash
-npx entkapp --cwd ./mein-projekt   # Analysiert ein spezifisches Verzeichnis
-npx entkapp --verbose              # Aktiviert detailliertes Logging
-npx entkapp --version              # Zeigt die Versionsnummer
-npx entkapp --help                 # Zeigt das Hilfe-Panel
+npx entkapp --cwd ./my-project  -r    # Analyzes a specific directory
+npx entkapp --verbose -r              # Enables detailed logging
+npx entkapp --version                 # Displays the version number
+npx entkapp --help                    # Displays the help panel
 ```
 
-## 🧠 Fortgeschrittene Architektur
+## 🧠 Advanced Architecture
 
 ### Incremental Caching
-`entkapp` verwendet eine persistente Graph-Status-Schicht (`.entkapp-cache`). Es berechnet SHA-256 Hashes von Dateipuffern, um das AST-Parsing für unveränderte Dateien zu überspringen.
+`entkapp` uses a persistent graph state layer (`.entkapp-cache`). It calculates SHA-256 hashes of file buffers to skip AST parsing for unchanged files.
 
 ### Parallel Analysis
-Bei größeren Codebasen verteilt `entkapp` die Arbeitslast automatisch auf mehrere CPU-Threads mittels Node.js Worker Threads.
-
-### Pluggable Architecture
-Die Engine ist modular aufgebaut:
-- **`EntkappEngine`**: Der zentrale Orchestrator.
-- **`PluginRegistry`**: Verwaltet den Lebenszyklus der Framework-Plugins.
-- **`ASTAnalyzer` / `OxcAnalyzer`**: Multi-pass AST-Walker für tiefgehende Analysen.
-- **`SelfHealer`**: Transaktionales Refactoring mit Git-State-Capture und Rollback.
+For larger codebases, `entkapp` automatically distributes the workload across multiple CPU threads using Node.js Worker Threads.
 
-## 📄 Lizenz
+## 📄 License
 
-Apache-2.0
+Apache-2.0

package/bin/cli.js

@@ -109,7 +109,7 @@ async function bootstrap() {
     try {
       const { ConfigLoader } = await import('../src/resolution/ConfigLoader.js');
       const loader = new ConfigLoader(targetCwd);
-      localConfig = await loader.loadConfig(targetCwd);
+      localConfig = await loader.loadConfig();
     } catch (e) {}
 
     // Merge options with local config

package/entkapp/config.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://unpkg.com/entkapp@5.2.4/schema.json"
+  "$schema": "https://unpkg.com/entkapp@latest/schema.json",
   "interface": "CLI",
   "useBuiltinPlugins": true,
   "useCustomPlugins": true,
@@ -26,5 +26,21 @@
     "dist",
     "build",
     "coverage"
-  ]
+  ],
+  "entryPoints": [],
+  "workspace": {
+    "enabled": false,
+    "enforcePackageBoundaries": true,
+    "checkVersionMismatches": true
+  },
+  "tsconfig": {
+    "filename": "tsconfig.json",
+    "followProjectReferences": true,
+    "resolveAliases": true
+  },
+  "buildScripts": {
+    "scanWorkspaceScripts": true,
+    "scanCIWorkflows": true,
+    "scanConfigFiles": true
+  }
 }

package/entkapp/plugins/README.md

@@ -1,19 +1,59 @@
-# entkapp Plugins
+# 🔌 entkapp Plugins (v5.3.0)
 
-This directory is for your custom plugins. entkapp will automatically load any `.js` or `.mjs` files placed here if `useCustomPlugins` is set to `true` in your `config.json`.
+Dieses Verzeichnis dient für deine benutzerdefinierten Plugins. entkapp lädt automatisch alle `.js` oder `.mjs` Dateien aus diesem Ordner, wenn `useCustomPlugins` in deiner `config.json` auf `true` gesetzt ist.
 
-## Supported Ecosystems (Built-in)
+## 📦 Integrierte Framework- & Tool-Plugins (98 Gesamt)
 
-- **Next.js**: Handles pages, API routes, and App Router conventions.
-- **Nuxt**: Supports auto-imports and server routes.
-- **Remix**: Maps loaders, actions, and root exports.
-- **SvelteKit**: Tracks `+page`, `+layout`, and server-side scripts.
-- **Astro**: Analyzes `.astro` files and static paths.
+entkapp verfügt über eine massive Bibliothek von 98 integrierten Plugins, die automatisch die Architektur deiner Codebase erkennen und analysieren.
 
-## Knip Compatibility
+### 🖼️ Frontend Frameworks & Meta-Frameworks
+- **Next.js** (App Router, Pages Router)
+- **React**, **Preact**, **Solid**, **Qwik**, **Lit**, **Angular**, **Vue**, **Svelte**
+- **Nuxt**, **Remix**, **SvelteKit**, **Astro**, **Vitepress**, **Gatsby**, **RedwoodJS**
 
-entkapp supports Knip-style plugins. You can drop Knip plugins into this folder, and the engine will attempt to wrap them for use within the entkapp ecosystem.
+### 🌐 State Management & Routing
+- **Redux**, **Zustand**, **Jotai**, **Recoil**, **MobX**, **Pinia**, **TanStack Query**
+- **React Router**, **TanStack Router**, **Vue Router**
 
-## Documentation
+### 🛠️ Build Tools & Monorepo
+- **Vite**, **Esbuild**, **Rollup**, **Webpack**, **Parcel**, **TypeScript**, **Babel**, **SWC**
+- **Turbo**, **Nx**, **Lerna**, **Rush**, **Moon**, **Bazel**
 
-For a detailed guide on how to build your own plugins, please refer to the [Plugin Development Guide](../../docs/guide.md#plugin-development).
+### 🎨 Styling & UI Components
+- **Tailwind CSS**, **PostCSS**, **UnoCSS**, **Stylelint**, **RTLCSS**
+- **Ant Design (Antd)**, **Material UI (Mui)**, **Shadcn/UI**, **Radix UI**, **Chakra UI**
+- **Framer Motion**, **GSAP**
+
+### 🧪 Testing & Quality
+- **Jest**, **Vitest**, **Playwright**, **Cypress**, **Storybook**, **MSW**
+- **ESLint**, **Prettier**, **Biome**, **Oxlint**, **Husky**, **Lint-Staged**, **Commitlint**, **Changesets**
+
+### ☁️ Backend, API & Database
+- **Express**, **Fastify**, **NestJS**, **Hono**, **Koa**, **Elysia**, **Hapi**, **Grammy**
+- **GraphQL**, **Apollo**, **TRPC**, **Socket.io**
+- **Prisma**, **Drizzle**, **Mongoose**, **TypeORM**, **Supabase**, **Firebase**, **Clerk**
+
+### 🔧 Infrastructure & Dev Tools
+- **GitHub Actions**, **Docker**, **Terraform**, **EditorConfig**, **Dotenv**
+- **Nvm**, **Volta**, **Pnpm**, **Yarn**, **Bun**
+- **Swiper**, **Quill**, **Envelop**, **Nitro Modules**, **CKEditor Engine**
+
+---
+
+## 🛠️ Eigene Plugins erstellen
+
+Du kannst die Funktionalität von entkapp erweitern, indem du eine Plugin-Klasse erstellst:
+
+```javascript
+export default class MyCustomPlugin {
+  name = 'my-custom-plugin';
+  
+  async onAnalyze(context) {
+    // Deine Logik hier
+  }
+}
+```
+
+## 📜 Dokumentation
+
+Für eine detaillierte Anleitung zur Plugin-Entwicklung besuche bitte den [Plugin Development Guide](https://dreamlongyt.github.io/entkapp/).

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "name": "entkapp",
-  "version": "5.2.4",
-  "description": "The Ultimate Enterprise Codebase Janitor. Faster than Knip with OXC integration, type-aware analysis, and automated structural healing. Fully standalone - solving what Knip cannot.",
+  "version": "5.3.0",
+  "description": "The Ultimate Enterprise Codebase Janitor. High-speed OXC integration, type-aware analysis, and automated structural healing. Fully standalone architectural orchestrator.",
   "type": "module",
   "main": "index.js",
   "bin": {

package/schema.json

@@ -1,4 +1,3 @@
-
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "entkapp Configuration Schema",
@@ -46,11 +45,15 @@
       "type": "array",
       "items": {
         "type": "string",
-        "enum": ["nextjs", "nuxt", "remix", "sveltekit", "astro", "typescript", "vite", "webpack", "react", "vue", "angular"]
+        "enum": [
+          "nextjs", "nuxt", "remix", "sveltekit", "astro",
+          "typescript", "vite", "webpack", "react", "vue", "angular",
+          "turbo", "nx", "lerna"
+        ]
       }
     },
     "ignoreDependencies": {
-      "description": "Dependencies that should never be reported as unused.",
+      "description": "Dependencies that should never be reported as unused. Supports glob patterns like '@types/*'.",
       "type": "array",
       "items": {
         "type": "string"
@@ -64,6 +67,87 @@
         "type": "string"
       },
       "default": ["node_modules", ".git", "dist", "build", "coverage"]
+    },
+    "entryPoints": {
+      "description": "Explicit entry point files to protect from orphan detection. Supports glob patterns.",
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "workspace": {
+      "description": "Monorepo workspace configuration.",
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "Force-enable monorepo workspace mode (auto-detected from package.json workspaces or pnpm-workspace.yaml).",
+          "type": "boolean",
+          "default": false
+        },
+        "packages": {
+          "description": "Override workspace package glob patterns (e.g. ['packages/*', 'apps/*']).",
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "ignoredPackages": {
+          "description": "Workspace packages to exclude from analysis.",
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "enforcePackageBoundaries": {
+          "description": "Report errors when a workspace package imports another without declaring it as a dependency.",
+          "type": "boolean",
+          "default": true
+        },
+        "checkVersionMismatches": {
+          "description": "Report warnings when the same dependency has different versions across workspace packages.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "tsconfig": {
+      "description": "TypeScript configuration options.",
+      "type": "object",
+      "properties": {
+        "filename": {
+          "description": "Path to the root tsconfig.json file.",
+          "type": "string",
+          "default": "tsconfig.json"
+        },
+        "followProjectReferences": {
+          "description": "Follow TypeScript project references to discover workspace packages.",
+          "type": "boolean",
+          "default": true
+        },
+        "resolveAliases": {
+          "description": "Use tsconfig paths/baseUrl to resolve module aliases.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "buildScripts": {
+      "description": "Build script analysis configuration.",
+      "type": "object",
+      "properties": {
+        "scanWorkspaceScripts": {
+          "description": "Also scan package.json scripts in all workspace packages (not just root).",
+          "type": "boolean",
+          "default": true
+        },
+        "scanCIWorkflows": {
+          "description": "Scan .github/workflows YAML files for tool usage.",
+          "type": "boolean",
+          "default": true
+        },
+        "scanConfigFiles": {
+          "description": "Detect tool usage from config files (vite.config.ts, jest.config.js, etc.).",
+          "type": "boolean",
+          "default": true
+        }
+      }
     }
   }
 }

package/src/index.js

@@ -7,7 +7,7 @@ import { CodeSmellAnalyzer } from './analyzers/CodeSmellAnalyzer.js';
 
 /**
  * ============================================================================
- * 📦 entkapp v4.6.0: Unified Architectural Refactoring Orchestrator
+ * 📦 entkapp v5.3.0: Unified Architectural Refactoring Orchestrator
  * ============================================================================
  * Main execution bridge managing multi-pass compilation cycles, semantic cross-linking,
  * supply-chain validation audits, and automated structural healing rollbacks.
@@ -64,6 +64,11 @@ export class RefactoringEngine {
     this.resolver = new DependencyResolver(this.context, this.pathMapper, this.workspaceGraph);
     this.circularDetector = new CircularDetector(this.context);
     
+    // Lazy import DependencyProfiler
+    import('./resolution/DependencyProfiler.js').then(({ DependencyProfiler }) => {
+      this.dependencyProfiler = new DependencyProfiler(this.context);
+    }).catch(() => {});
+    
     // Stage 3: Wire official AST Syntax parsers and framework processors
     this.analyzer = new ASTAnalyzer(this.context);
     this.oxcAnalyzer = new OxcAnalyzer(this.context);
@@ -115,6 +120,16 @@ export class RefactoringEngine {
       await this.workspaceGraph.initializeWorkspaceMesh();
       if (this.context.isWorkspaceEnabled) {
         console.log(ansis.dim('🌐 Monorepo workspace detected – mapping package mesh layers...'));
+        // Expose workspaceGraph on context for WorkspaceDiagnostic and other components
+        this.context.workspaceGraph = this.workspaceGraph;
+        // Reload PathMapper aliases now that workspace roots are known
+        await this.pathMapper.loadMappings(this.context.tsconfigFilename);
+        if (this.context.verbose) {
+          console.log(`[Workspace] Found ${this.workspaceGraph.packageManifests.size} workspace packages:`);
+          for (const [dir, manifest] of this.workspaceGraph.packageManifests.entries()) {
+            console.log(ansis.dim(`  • ${manifest.name || dir}`));
+          }
+        }
       }
 
       // UPGRADE: Always clear cache for fresh analysis run
@@ -141,6 +156,12 @@ export class RefactoringEngine {
       this.context.metrics.totalFilesScanned = fileList.length;
 
       // Identify meta-framework setups (Next.js, Remix, Nuxt, etc.)
+      if (this.dependencyProfiler) {
+        const usedDeps = await this.dependencyProfiler.traceImplicitInvocations(this.context.cwd);
+        for (const dep of usedDeps) {
+          this.context.usedExternalPackages.add(dep);
+        }
+      }
       const activeFrameworkEcosystems = await this.magicDetector.identifyActiveProjectEcosystems(this.context.cwd);
 
       // Separate explicit configuration packages out for targeted supply chain security checks
@@ -985,6 +1006,20 @@ export class RefactoringEngine {
         peerDependencies: Object.keys(data.peerDependencies || {}),
         optionalDependencies: Object.keys(data.optionalDependencies || {})
       });
+      
+      // Also register workspace manifests if not already done
+      if (this.context.isWorkspaceEnabled && this.workspaceGraph) {
+        for (const [dir, manifest] of this.workspaceGraph.packageManifests.entries()) {
+          if (!this.context.manifestDependencies.has(manifest.manifestPath)) {
+            this.context.manifestDependencies.set(manifest.manifestPath, {
+              dependencies: Object.keys(manifest.dependencies || {}),
+              devDependencies: Object.keys(manifest.devDependencies || {}),
+              peerDependencies: Object.keys(manifest.peerDependencies || {}),
+              optionalDependencies: Object.keys(manifest.optionalDependencies || {})
+            });
+          }
+        }
+      }
     } catch (e) {}
   }
 

package/src/resolution/ConfigLoader.js

@@ -1,4 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * ConfigLoader
+ * Loads and merges entkapp configuration from multiple sources:
+ * - entkapp/config.json (project config)
+ * - entkapp.config.js / entkapp.config.mjs (JS config)
+ * - package.json "entkapp" key
+ * - CLI flags (passed as overrides)
+ */
 export class ConfigLoader {
-  constructor(cwd) { this.cwd = cwd; }
-  async loadConfig() { return {}; }
+  constructor(cwd) { 
+    this.cwd = cwd; 
+  }
+
+  async loadConfig(overrides = {}) {
+    let config = this._defaultConfig();
+
+    // 1. Try entkapp/config.json
+    const jsonConfigPath = path.join(this.cwd, 'entkapp', 'config.json');
+    try {
+      const raw = await fs.readFile(jsonConfigPath, 'utf8');
+      // Strip comments from JSON (JSONC support)
+      const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+      const parsed = JSON.parse(stripped);
+      config = this._merge(config, parsed);
+    } catch (e) {}
+
+    // 2. Try entkapp.config.js / entkapp.config.mjs
+    for (const configFile of ['entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
+      const jsConfigPath = path.join(this.cwd, configFile);
+      try {
+        const mod = await import(jsConfigPath);
+        const jsConfig = mod.default || mod;
+        if (typeof jsConfig === 'object') {
+          config = this._merge(config, jsConfig);
+          break;
+        }
+      } catch (e) {}
+    }
+
+    // 3. Try package.json "entkapp" key
+    const pkgPath = path.join(this.cwd, 'package.json');
+    try {
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+      if (pkg.entkapp && typeof pkg.entkapp === 'object') {
+        config = this._merge(config, pkg.entkapp);
+      }
+    } catch (e) {}
+
+    // 4. Apply CLI overrides
+    config = this._merge(config, overrides);
+
+    return config;
+  }
+
+  _defaultConfig() {
+    return {
+      interface: 'CLI',
+      useBuiltinPlugins: true,
+      useCustomPlugins: true,
+      options: {
+        verbose: false,
+        fastMode: true,
+        selfHealing: true
+      },
+      enabledPlugins: [],
+      ignoreDependencies: ['entkapp', '@types/*'],
+      exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
+      entryPoints: [],
+      workspace: false
+    };
+  }
+
+  _merge(base, override) {
+    if (!override || typeof override !== 'object') return base;
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+      if (key === 'options' && typeof override[key] === 'object') {
+        result.options = { ...(base.options || {}), ...override[key] };
+      } else if (Array.isArray(override[key])) {
+        result[key] = override[key];
+      } else {
+        result[key] = override[key];
+      }
+    }
+    return result;
+  }
 }

package/src/resolution/DepencyResolver.js

@@ -25,8 +25,23 @@ export class DependencyResolver {
   resolveModulePath(sourceFile, specifier) {
     const cleanSource = this.normalizePath(sourceFile);
     
+    // Check if it's a workspace package reference
+    if (this.context.isWorkspaceEnabled && this.workspaceGraph && this.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+      const match = this.workspaceGraph.getWorkspacePackageMatch(specifier);
+      if (match && match.entryPoints && match.entryPoints.length > 0) {
+        // Return the first entry point for the workspace package
+        return this.normalizePath(match.entryPoints[0]);
+      }
+    }
+
     // UPGRADE: Use PathMapper for sophisticated resolution (TS-to-JS, aliases, etc.)
     if (this.pathMapper) {
+      // Allow pathMapper to resolve aliases directly from specifier
+      const aliasResolved = this.pathMapper.resolvePath(specifier);
+      if (aliasResolved && aliasResolved !== specifier && existsSync(aliasResolved)) {
+         return this.normalizePath(aliasResolved);
+      }
+
       const dir = path.dirname(cleanSource);
       const target = path.resolve(dir, specifier);
       const resolved = this.pathMapper.resolvePath(target);

package/src/resolution/DependencyProfiler.js

@@ -146,9 +146,44 @@ export class DependencyProfiler {
     const usedPackages = new Set();
     const usedBinaries = new Set(); // NEW: Track which binaries are actually used
     
-    // 1. Scan package.json scripts
+    // 1. Scan package.json scripts (Root)
+    await this._scanDirectoryForConfigs(projectRoot, usedPackages, usedBinaries);
+
+    // 1.5 Scan Workspace package.json scripts and configs
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._scanDirectoryForConfigs(workspaceRoot, usedPackages, usedBinaries);
+      }
+    }
+
+    // 2. Scan CI workflows
+    try {
+      const githubWorkflows = path.join(projectRoot, '.github/workflows');
+      const files = await fs.readdir(githubWorkflows).catch(() => []);
+      for (const file of files) {
+        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
+          this.extractPackagesFromScript(content, usedPackages, usedBinaries);
+        }
+      }
+    } catch (e) {}
+
+    // 4. Identify Unused Binaries (Root)
+    await this._identifyUnusedBinaries(projectRoot, usedBinaries);
+    
+    // 4.5 Identify Unused Binaries (Workspaces)
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const workspaceRoot of this.context.monorepoPackageRoots) {
+        await this._identifyUnusedBinaries(workspaceRoot, usedBinaries);
+      }
+    }
+
+    return usedPackages;
+  }
+
+  async _scanDirectoryForConfigs(dir, usedPackages, usedBinaries) {
     try {
-      const pkgJsonPath = path.join(projectRoot, 'package.json');
+      const pkgJsonPath = path.join(dir, 'package.json');
       const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
       
       if (pkg.scripts) {
@@ -157,7 +192,6 @@ export class DependencyProfiler {
         }
       }
 
-      // Detect @types/* usage
       if (pkg.dependencies || pkg.devDependencies) {
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         for (const depName of Object.keys(allDeps)) {
@@ -168,21 +202,8 @@ export class DependencyProfiler {
       }
     } catch (e) {}
 
-    // 2. Scan CI workflows
     try {
-      const githubWorkflows = path.join(projectRoot, '.github/workflows');
-      const files = await fs.readdir(githubWorkflows).catch(() => []);
-      for (const file of files) {
-        if (file.endsWith('.yml') || file.endsWith('.yaml')) {
-          const content = await fs.readFile(path.join(githubWorkflows, file), 'utf8');
-          this.extractPackagesFromScript(content, usedPackages, usedBinaries);
-        }
-      }
-    } catch (e) {}
-
-    // 3. Scan config files
-    try {
-      const dirEntries = await fs.readdir(projectRoot, { withFileTypes: true });
+      const dirEntries = await fs.readdir(dir, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!entry.isFile()) continue;
         const fileName = entry.name;
@@ -194,15 +215,14 @@ export class DependencyProfiler {
         }
       }
     } catch (e) {}
+  }
 
-    // 4. Identify Unused Binaries
-    // Scan node_modules/.bin for all available binaries
+  async _identifyUnusedBinaries(dir, usedBinaries) {
     try {
-      const binDir = path.join(projectRoot, 'node_modules', '.bin');
+      const binDir = path.join(dir, 'node_modules', '.bin');
       const availableBinaries = await fs.readdir(binDir).catch(() => []);
       
       for (const bin of availableBinaries) {
-        // Skip hidden files or package manager internal bins
         if (bin.startsWith('.') || ['npm', 'pnpm', 'yarn', 'bun'].includes(bin)) continue;
         
         if (!usedBinaries.has(bin)) {
@@ -210,8 +230,6 @@ export class DependencyProfiler {
         }
       }
     } catch (e) {}
-
-    return usedPackages;
   }
 
   extractPackagesFromScript(script, packageCollector, binaryCollector) {

package/src/resolution/PathMapper.js

@@ -1,13 +1,35 @@
 import fs from 'fs';
 import path from 'path';
+import { TSConfigLoader } from './TSConfigLoader.js';
 
 export class PathMapper {
   constructor(context) { 
     this.context = context; 
+    this.aliasMappers = []; // list of alias mapping functions
   }
   
-  async loadMappings() {
-    // Tsconfig paths can be loaded here later
+  async loadMappings(tsconfigFilename = 'tsconfig.json') {
+    // Load root tsconfig
+    const loader = new TSConfigLoader(this.context.cwd);
+    const config = loader.load();
+    if (config) {
+      const mapper = loader.getAliasMapper(config);
+      this.aliasMappers.push(mapper);
+      if (this.context.verbose) console.log(`[PathMapper] Loaded root tsconfig aliases`);
+    }
+
+    // Load workspace tsconfigs if available
+    if (this.context.isWorkspaceEnabled && this.context.monorepoPackageRoots) {
+      for (const root of this.context.monorepoPackageRoots) {
+        const wsLoader = new TSConfigLoader(root);
+        const wsConfig = wsLoader.load();
+        if (wsConfig) {
+          const wsMapper = wsLoader.getAliasMapper(wsConfig);
+          this.aliasMappers.push(wsMapper);
+          if (this.context.verbose) console.log(`[PathMapper] Loaded workspace tsconfig aliases from ${root}`);
+        }
+      }
+    }
   }
 
   /**
@@ -18,25 +40,36 @@ export class PathMapper {
   resolvePath(p) {
     if (!p || typeof p !== 'string') return p;
 
+    let resolvedP = p;
+
+    // Try alias mappers first
+    for (const mapper of this.aliasMappers) {
+      const mapped = mapper(resolvedP);
+      if (mapped !== resolvedP && fs.existsSync(mapped)) {
+        resolvedP = mapped;
+        break;
+      }
+    }
+
     // FIX 1: If the import ends with .js, translate it to .ts for the search
-    if (p.endsWith('.js')) {
-      const tsPath = p.slice(0, -3) + '.ts';
+    if (resolvedP.endsWith('.js')) {
+      const tsPath = resolvedP.slice(0, -3) + '.ts';
       if (fs.existsSync(tsPath)) return tsPath;
     }
 
     // FIX 2: If the import ends with .jsx, translate it to .tsx for the search
-    if (p.endsWith('.jsx')) {
-      const tsxPath = p.slice(0, -4) + '.tsx';
+    if (resolvedP.endsWith('.jsx')) {
+      const tsxPath = resolvedP.slice(0, -4) + '.tsx';
       if (fs.existsSync(tsxPath)) return tsxPath;
     }
 
     // FIX 3: Support for directory imports (z.B. ./adapters -> ./adapters/index.ts)
     try {
-      const stat = fs.statSync(p);
+      const stat = fs.statSync(resolvedP);
       if (stat.isDirectory()) {
         const extensions = ['.ts', '.tsx', '.js', '.jsx'];
         for (const ext of extensions) {
-          const indexPath = path.join(p, `index${ext}`);
+          const indexPath = path.join(resolvedP, `index${ext}`);
           if (fs.existsSync(indexPath)) return indexPath;
         }
       }
@@ -44,6 +77,6 @@ export class PathMapper {
       // File does not exist or is not a directory, continue with default
     }
 
-    return p; 
+    return resolvedP; 
   }
 }

package/src/resolution/TSConfigLoader.js

@@ -9,39 +9,102 @@ export class TSConfigLoader {
 
     /**
      * Lädt und parst die tsconfig.json.
+     * Unterstützt JSONC (Kommentare), extends, und project references.
+     * @param {string} [filename='tsconfig.json'] - Name der tsconfig-Datei
      * @returns {Object|null} Parsed config oder null.
      */
-    load() {
-        const configPath = path.join(this.targetDir, 'tsconfig.json');
+    load(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
         if (!fs.existsSync(configPath)) return null;
 
         try {
             const content = fs.readFileSync(configPath, 'utf8');
-            const result = ts.parseConfigFileTextWithComments(configPath, content);
+            const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
             
-            if (result.error) {
+            if (readResult.error) {
                 return null;
             }
 
             const parsed = ts.parseJsonConfigFileContent(
-                result.config,
+                readResult.config,
                 ts.sys,
                 this.targetDir
             );
 
+            // Attach raw config for reference inspection
+            parsed._rawConfig = readResult.config;
+
             return parsed;
         } catch (e) {
             return null;
         }
     }
 
+    /**
+     * Extracts project references from tsconfig (composite monorepo support).
+     * @returns {string[]} Array of referenced tsconfig paths
+     */
+    getProjectReferences(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
+        if (!fs.existsSync(configPath)) return [];
+
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            // Strip comments
+            const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const raw = JSON.parse(stripped);
+            const refs = raw.references || [];
+            return refs.map(ref => {
+                const refPath = path.resolve(this.targetDir, ref.path);
+                // If it's a directory, look for tsconfig.json inside
+                if (fs.existsSync(refPath) && fs.statSync(refPath).isDirectory()) {
+                    return path.join(refPath, 'tsconfig.json');
+                }
+                return refPath;
+            });
+        } catch (e) {
+            return [];
+        }
+    }
+
+    /**
+     * Extracts the "extends" chain from tsconfig.
+     * @returns {string[]} Array of extended tsconfig paths
+     */
+    getExtendsChain(filename = 'tsconfig.json') {
+        const configPath = path.join(this.targetDir, filename);
+        if (!fs.existsSync(configPath)) return [];
+
+        const chain = [];
+        let currentPath = configPath;
+
+        for (let i = 0; i < 10; i++) { // limit depth to avoid infinite loops
+            try {
+                const content = fs.readFileSync(currentPath, 'utf8');
+                const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                const raw = JSON.parse(stripped);
+                if (!raw.extends) break;
+                const extendedPath = path.resolve(path.dirname(currentPath), raw.extends);
+                const resolvedPath = extendedPath.endsWith('.json') ? extendedPath : extendedPath + '.json';
+                if (!fs.existsSync(resolvedPath)) break;
+                chain.push(resolvedPath);
+                currentPath = resolvedPath;
+            } catch (e) {
+                break;
+            }
+        }
+
+        return chain;
+    }
+
     /**
      * Erstellt eine Mapping-Funktion für Aliases aus der tsconfig.
+     * Berücksichtigt baseUrl, paths und project references.
      * @param {Object} parsedConfig 
      * @returns {Function} Mapper function.
      */
     getAliasMapper(parsedConfig) {
-        if (!parsedConfig || !parsedConfig.options || !parsedConfig.options.paths) {
+        if (!parsedConfig || !parsedConfig.options) {
             return (source) => source;
         }
 
@@ -49,19 +112,31 @@ export class TSConfigLoader {
         const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
 
         return (source) => {
+            // If no paths configured, still try baseUrl resolution
+            if (!paths) {
+                if (baseUrl && !source.startsWith('.') && !source.startsWith('/') && !source.startsWith('@')) {
+                    const candidate = path.resolve(base, source);
+                    const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+                    for (const ext of extensions) {
+                        if (fs.existsSync(candidate + ext)) return candidate + ext;
+                    }
+                }
+                return source;
+            }
+
             for (const pattern in paths) {
-                const regexPattern = pattern.replace(/\*/, '(.*)');
+                const regexPattern = pattern.replace(/\*/g, '(.*)');
                 const regex = new RegExp(`^${regexPattern}$`);
                 const match = source.match(regex);
 
                 if (match) {
                     const replacements = paths[pattern];
                     for (const replacement of replacements) {
-                        const resolvedReplacement = replacement.replace(/\*/, match[1]);
+                        const resolvedReplacement = replacement.replace(/\*/g, match[1] || '');
                         const fullPath = path.resolve(base, resolvedReplacement);
                         
-                        // Prüfe ob Datei existiert
-                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+                        // Check with common extensions
+                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
                         for (const ext of extensions) {
                             if (fs.existsSync(fullPath + ext)) {
                                 return fullPath + ext;
@@ -73,4 +148,15 @@ export class TSConfigLoader {
             return source;
         };
     }
+
+    /**
+     * Returns all include/exclude glob patterns from tsconfig.
+     */
+    getIncludeExcludePatterns(parsedConfig) {
+        if (!parsedConfig || !parsedConfig._rawConfig) return { include: [], exclude: [] };
+        return {
+            include: parsedConfig._rawConfig.include || [],
+            exclude: parsedConfig._rawConfig.exclude || []
+        };
+    }
 }

package/src/resolution/WorkSpaceGraph.js

@@ -1,8 +1,183 @@
+import fs from 'fs/promises';
+import path from 'path';
+
 export class WorkspaceGraph {
   constructor(context) { 
     this.context = context; 
-    this.packageManifests = new Map();
+    this.packageManifests = new Map(); // dirPath -> manifestData
+    this.workspacePackages = new Map(); // packageName -> dirPath
+    this.tsconfigPaths = new Map(); // packageName -> tsconfigData
+  }
+
+  async initializeWorkspaceMesh() {
+    const rootPkgPath = path.join(this.context.cwd, 'package.json');
+    try {
+      const rootPkg = JSON.parse(await fs.readFile(rootPkgPath, 'utf8'));
+      let workspaces = [];
+
+      // 1. Detect Workspaces (npm/yarn/pnpm/lerna)
+      if (rootPkg.workspaces) {
+        workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces.packages || [];
+      } else {
+        // Fallback for pnpm-workspace.yaml
+        const pnpmWorkspacePath = path.join(this.context.cwd, 'pnpm-workspace.yaml');
+        try {
+          const yaml = await fs.readFile(pnpmWorkspacePath, 'utf8');
+          const match = yaml.match(/packages:\n((?:\s+- .+\n?)+)/);
+          if (match) {
+            workspaces = match[1].split('\n')
+              .filter(line => line.trim().startsWith('-'))
+              .map(line => line.replace('-', '').trim().replace(/['"]/g, ''));
+          }
+        } catch (e) {}
+      }
+
+      if (workspaces.length > 0) {
+        this.context.isWorkspaceEnabled = true;
+        if (this.context.verbose) console.log(`[Workspace] Detected workspaces:`, workspaces);
+
+        for (const pattern of workspaces) {
+          const matches = await this._expandGlob(pattern, this.context.cwd);
+          for (const matchDir of matches) {
+            const pkgPath = path.join(matchDir, 'package.json');
+            try {
+              const pkgData = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+              const normalizedDir = matchDir.replace(/\\/g, '/');
+              
+              this.packageManifests.set(normalizedDir, {
+                rootDirectory: normalizedDir,
+                manifestPath: pkgPath.replace(/\\/g, '/'),
+                name: pkgData.name,
+                dependencies: pkgData.dependencies || {},
+                devDependencies: pkgData.devDependencies || {},
+                peerDependencies: pkgData.peerDependencies || {},
+                scripts: pkgData.scripts || {},
+                entryPoints: this.calculatePackageExportsEntries(pkgData, normalizedDir)
+              });
+
+              if (pkgData.name) {
+                this.workspacePackages.set(pkgData.name, normalizedDir);
+                this.context.monorepoPackageRoots.add(normalizedDir);
+              }
+
+              // Also try to load tsconfig.json for this workspace
+              const tsconfigPath = path.join(matchDir, 'tsconfig.json');
+              try {
+                const tsconfigData = JSON.parse(await fs.readFile(tsconfigPath, 'utf8'));
+                if (pkgData.name) this.tsconfigPaths.set(pkgData.name, tsconfigData);
+              } catch(e) {}
+
+            } catch (e) {}
+          }
+        }
+      }
+    } catch (e) {
+      if (this.context.verbose) console.log('[Workspace] No root package.json found or invalid.');
+    }
+  }
+
+  calculatePackageExportsEntries(pkgData, dirPath) {
+    const entries = [];
+    const addEntry = (p) => {
+      if (typeof p === 'string') entries.push(path.resolve(dirPath, p).replace(/\\/g, '/'));
+    };
+
+    if (pkgData.main) addEntry(pkgData.main);
+    if (pkgData.module) addEntry(pkgData.module);
+    if (pkgData.source) addEntry(pkgData.source);
+    if (pkgData.types) addEntry(pkgData.types);
+    if (pkgData.typings) addEntry(pkgData.typings);
+
+    if (pkgData.bin) {
+      if (typeof pkgData.bin === 'string') addEntry(pkgData.bin);
+      else Object.values(pkgData.bin).forEach(addEntry);
+    }
+
+    if (pkgData.exports) {
+      const traverseExports = (obj) => {
+        if (typeof obj === 'string') {
+          addEntry(obj);
+        } else if (typeof obj === 'object' && obj !== null) {
+          for (const key in obj) traverseExports(obj[key]);
+        }
+      };
+      traverseExports(pkgData.exports);
+    }
+
+    return entries;
+  }
+
+  isLocalWorkspaceSpecifier(specifier) {
+    if (!specifier) return false;
+    // Direct match
+    if (this.workspacePackages.has(specifier)) return true;
+    // Sub-path match (e.g. @my-org/ui/components)
+    for (const pkgName of this.workspacePackages.keys()) {
+      if (specifier.startsWith(pkgName + '/')) return true;
+    }
+    return false;
+  }
+
+  getWorkspacePackageMatch(specifier) {
+    if (this.workspacePackages.has(specifier)) {
+      const dir = this.workspacePackages.get(specifier);
+      return this.packageManifests.get(dir);
+    }
+    for (const pkgName of this.workspacePackages.keys()) {
+      if (specifier.startsWith(pkgName + '/')) {
+        const dir = this.workspacePackages.get(pkgName);
+        return this.packageManifests.get(dir);
+      }
+    }
+    return null;
+  }
+
+  markWorkspacePackagesAsUsed() {
+    for (const [pkgName, dirPath] of this.workspacePackages.entries()) {
+      this.context.usedExternalPackages.add(pkgName);
+    }
+  }
+
+  /**
+   * Expands a workspace glob pattern (e.g. 'packages/*') to absolute directory paths.
+   * Supports single-level wildcards and direct paths.
+   */
+  async _expandGlob(pattern, cwd) {
+    const results = [];
+    
+    // Remove trailing slash
+    const cleanPattern = pattern.replace(/\/$/, '');
+    
+    // Handle simple wildcard patterns like 'packages/*' or 'apps/*'
+    if (cleanPattern.includes('*')) {
+      const parts = cleanPattern.split('/');
+      const wildcardIndex = parts.findIndex(p => p.includes('*'));
+      const baseDir = path.join(cwd, ...parts.slice(0, wildcardIndex));
+      
+      try {
+        const entries = await fs.readdir(baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            const fullPath = path.join(baseDir, entry.name);
+            // Check if it has a package.json
+            try {
+              await fs.access(path.join(fullPath, 'package.json'));
+              results.push(fullPath.replace(/\\/g, '/'));
+            } catch (e) {}
+          }
+        }
+      } catch (e) {}
+    } else {
+      // Direct path
+      const fullPath = path.resolve(cwd, cleanPattern);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) {
+          results.push(fullPath.replace(/\\/g, '/'));
+        }
+      } catch (e) {}
+    }
+    
+    return results;
   }
-  async initializeWorkspaceMesh() {}
-  markWorkspacePackagesAsUsed() {}
 }

package/src/resolution/WorkspaceDiagnostic.js

@@ -1,5 +1,139 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * WorkspaceDiagnostic
+ * Performs health checks and architectural boundary enforcement for Monorepo workspaces.
+ * Detects cross-package import violations, version mismatches, and missing workspace declarations.
+ */
 export class WorkspaceDiagnostic {
-  constructor(context) { this.context = context; }
-  async checkWorkspaceHealth() { return []; }
-  enforceBoundaries(filePath, imports) { return []; }
+  constructor(context) { 
+    this.context = context; 
+    this.findings = [];
+  }
+
+  async checkWorkspaceHealth() {
+    this.findings = [];
+
+    if (!this.context.isWorkspaceEnabled) return this.findings;
+
+    const rootPkgPath = this.context.cwd ? path.join(this.context.cwd, 'package.json') : null;
+    let rootPkg = {};
+    try {
+      if (rootPkgPath) rootPkg = JSON.parse(await fs.readFile(rootPkgPath, 'utf8'));
+    } catch (e) {}
+
+    // 1. Check for version mismatches across workspace packages
+    const versionMap = new Map(); // dep name -> { version, source }
+    for (const [dir, manifest] of (this.context.monorepoPackageRoots || new Set()).entries ? [] : (this.context.monorepoPackageRoots || [])) {
+      // iterate over monorepoPackageRoots as a Set
+    }
+
+    // Use workspaceGraph if available
+    if (this.context.workspaceGraph && this.context.workspaceGraph.packageManifests) {
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        const allDeps = {
+          ...manifest.dependencies,
+          ...manifest.devDependencies
+        };
+        for (const [dep, version] of Object.entries(allDeps)) {
+          if (!versionMap.has(dep)) {
+            versionMap.set(dep, []);
+          }
+          versionMap.get(dep).push({ version, source: manifest.name || dir });
+        }
+      }
+
+      // Report version mismatches
+      for (const [dep, usages] of versionMap.entries()) {
+        const uniqueVersions = new Set(usages.map(u => u.version));
+        if (uniqueVersions.size > 1) {
+          this.findings.push({
+            type: 'version-mismatch',
+            severity: 'warning',
+            message: `Dependency "${dep}" has conflicting versions across workspace packages: ${[...uniqueVersions].join(', ')}`,
+            packages: usages.map(u => u.source)
+          });
+        }
+      }
+
+      // 2. Check for missing workspace package declarations in root
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        if (!manifest.name) continue;
+        const rootDeps = {
+          ...rootPkg.dependencies,
+          ...rootPkg.devDependencies,
+          ...rootPkg.peerDependencies
+        };
+        // If the workspace package is referenced in root deps but not as "workspace:*"
+        if (rootDeps[manifest.name] && !rootDeps[manifest.name].startsWith('workspace:')) {
+          this.findings.push({
+            type: 'workspace-declaration-missing',
+            severity: 'info',
+            message: `Workspace package "${manifest.name}" is referenced in root package.json without "workspace:" protocol`,
+            packages: ['root', manifest.name]
+          });
+        }
+      }
+
+      // 3. Check for packages that have no entry points defined
+      for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+        if (!manifest.entryPoints || manifest.entryPoints.length === 0) {
+          this.findings.push({
+            type: 'missing-entry-point',
+            severity: 'warning',
+            message: `Workspace package "${manifest.name || dir}" has no entry points (main/module/exports) defined in package.json`,
+            packages: [manifest.name || dir]
+          });
+        }
+      }
+    }
+
+    return this.findings;
+  }
+
+  enforceBoundaries(filePath, imports) {
+    const violations = [];
+    if (!this.context.isWorkspaceEnabled) return violations;
+    if (!this.context.workspaceGraph || !this.context.workspaceGraph.packageManifests) return violations;
+
+    // Determine which workspace package this file belongs to
+    let sourcePackage = null;
+    for (const [dir, manifest] of this.context.workspaceGraph.packageManifests.entries()) {
+      if (filePath.startsWith(dir + '/') || filePath.startsWith(dir + '\\')) {
+        sourcePackage = manifest;
+        break;
+      }
+    }
+
+    if (!sourcePackage) return violations;
+
+    // Check each import
+    for (const specifier of imports) {
+      if (!specifier || specifier.startsWith('.') || specifier.startsWith('/')) continue;
+
+      // Check if the import is a workspace package
+      if (this.context.workspaceGraph.isLocalWorkspaceSpecifier(specifier)) {
+        const targetManifest = this.context.workspaceGraph.getWorkspacePackageMatch(specifier);
+        if (targetManifest && targetManifest.name) {
+          // Check if the target package is declared as a dependency of the source package
+          const sourceDeps = {
+            ...sourcePackage.dependencies,
+            ...sourcePackage.devDependencies,
+            ...sourcePackage.peerDependencies
+          };
+          if (!sourceDeps[targetManifest.name]) {
+            violations.push({
+              type: 'undeclared-workspace-dependency',
+              severity: 'error',
+              message: `Package "${sourcePackage.name}" imports "${specifier}" but "${targetManifest.name}" is not declared as a dependency`,
+              file: filePath
+            });
+          }
+        }
+      }
+    }
+
+    return violations;
+  }
 }