driftdetect-core 0.7.1 → 0.8.1

package/dist/context/package-detector.js

@@ -0,0 +1,672 @@
+/**
+ * Package Detector
+ *
+ * @license Apache-2.0
+ *
+ * Detects packages in monorepos across different package managers.
+ * Supports npm/pnpm/yarn workspaces, Python, Go, Java, C#, PHP, and Rust.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { EventEmitter } from 'node:events';
+// =============================================================================
+// Constants
+// =============================================================================
+const LANGUAGE_MAP = {
+    npm: 'typescript',
+    pnpm: 'typescript',
+    yarn: 'typescript',
+    pip: 'python',
+    poetry: 'python',
+    cargo: 'rust',
+    go: 'go',
+    maven: 'java',
+    gradle: 'java',
+    composer: 'php',
+    nuget: 'csharp',
+    unknown: 'unknown',
+};
+// =============================================================================
+// Package Detector
+// =============================================================================
+/**
+ * Detects packages in monorepos
+ */
+export class PackageDetector extends EventEmitter {
+    rootDir;
+    cache = null;
+    constructor(rootDir) {
+        super();
+        this.rootDir = rootDir;
+    }
+    /**
+     * Detect monorepo structure
+     */
+    async detect() {
+        if (this.cache) {
+            return this.cache;
+        }
+        const structure = {
+            rootDir: this.rootDir,
+            isMonorepo: false,
+            packages: [],
+            packageManager: 'unknown',
+        };
+        const detectors = [
+            this.detectNpmWorkspaces.bind(this),
+            this.detectPnpmWorkspaces.bind(this),
+            this.detectYarnWorkspaces.bind(this),
+            this.detectPythonPackages.bind(this),
+            this.detectGoModules.bind(this),
+            this.detectMavenModules.bind(this),
+            this.detectGradleModules.bind(this),
+            this.detectComposerPackages.bind(this),
+            this.detectDotNetProjects.bind(this),
+            this.detectCargoWorkspaces.bind(this),
+        ];
+        for (const detector of detectors) {
+            try {
+                const result = await detector();
+                if (result.packages && result.packages.length > 0) {
+                    structure.packages.push(...result.packages);
+                    if (result.packageManager) {
+                        structure.packageManager = result.packageManager;
+                    }
+                    if (result.workspaceConfig) {
+                        structure.workspaceConfig = result.workspaceConfig;
+                    }
+                    structure.isMonorepo = result.packages.length > 1;
+                    break;
+                }
+            }
+            catch {
+                // Continue to next detector
+            }
+        }
+        if (structure.packages.length === 0) {
+            const rootPackage = await this.detectRootPackage();
+            if (rootPackage) {
+                structure.packages.push(rootPackage);
+                structure.packageManager = rootPackage.packageManager;
+            }
+        }
+        this.cache = structure;
+        this.emitEvent('monorepo:detected', undefined, {
+            isMonorepo: structure.isMonorepo,
+            packageCount: structure.packages.length,
+            packageManager: structure.packageManager,
+        });
+        return structure;
+    }
+    /**
+     * Get a specific package by name or path
+     */
+    async getPackage(nameOrPath) {
+        const structure = await this.detect();
+        const byName = structure.packages.find(p => p.name === nameOrPath);
+        if (byName)
+            return byName;
+        const normalizedPath = nameOrPath.replace(/\\/g, '/');
+        const byPath = structure.packages.find(p => p.path === normalizedPath ||
+            p.path.endsWith(normalizedPath) ||
+            normalizedPath.endsWith(p.path));
+        if (byPath)
+            return byPath;
+        const byPartialName = structure.packages.find(p => p.name.includes(nameOrPath) || nameOrPath.includes(p.name));
+        return byPartialName || null;
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache = null;
+    }
+    // ===========================================================================
+    // NPM/PNPM/Yarn Detection
+    // ===========================================================================
+    async detectNpmWorkspaces() {
+        const pkgPath = path.join(this.rootDir, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const workspacesRaw = pkg['workspaces'];
+        if (!workspacesRaw) {
+            return { packages: [], packageManager: 'npm' };
+        }
+        const workspaces = Array.isArray(workspacesRaw)
+            ? workspacesRaw
+            : (workspacesRaw['packages'] || []);
+        const packages = await this.resolveWorkspaceGlobs(workspaces, 'npm');
+        return {
+            packages,
+            packageManager: 'npm',
+            workspaceConfig: 'package.json',
+        };
+    }
+    async detectPnpmWorkspaces() {
+        const workspacePath = path.join(this.rootDir, 'pnpm-workspace.yaml');
+        try {
+            const content = await fs.readFile(workspacePath, 'utf-8');
+            const packagesMatch = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/);
+            if (!packagesMatch?.[1]) {
+                return { packages: [], packageManager: 'pnpm' };
+            }
+            const workspaces = packagesMatch[1]
+                .split('\n')
+                .map(line => line.replace(/^\s*-\s*['"]?/, '').replace(/['"]?\s*$/, ''))
+                .filter(line => line.length > 0);
+            const packages = await this.resolveWorkspaceGlobs(workspaces, 'pnpm');
+            return {
+                packages,
+                packageManager: 'pnpm',
+                workspaceConfig: 'pnpm-workspace.yaml',
+            };
+        }
+        catch {
+            return { packages: [], packageManager: 'pnpm' };
+        }
+    }
+    async detectYarnWorkspaces() {
+        const result = await this.detectNpmWorkspaces();
+        if (result.packages && result.packages.length > 0) {
+            try {
+                await fs.access(path.join(this.rootDir, 'yarn.lock'));
+                return { ...result, packageManager: 'yarn' };
+            }
+            catch {
+                // Not yarn
+            }
+        }
+        return { packages: [], packageManager: 'yarn' };
+    }
+    async resolveWorkspaceGlobs(globs, packageManager) {
+        const packages = [];
+        for (const glob of globs) {
+            const basePath = glob.replace(/\/?\*.*$/, '');
+            const fullBasePath = path.join(this.rootDir, basePath);
+            try {
+                const entries = await fs.readdir(fullBasePath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const pkgDir = path.join(fullBasePath, entry.name);
+                    const pkgJsonPath = path.join(pkgDir, 'package.json');
+                    try {
+                        const pkgContent = await fs.readFile(pkgJsonPath, 'utf-8');
+                        const pkg = JSON.parse(pkgContent);
+                        const relativePath = path.relative(this.rootDir, pkgDir).replace(/\\/g, '/');
+                        const pkgName = pkg['name'] || entry.name;
+                        const pkgVersion = pkg['version'];
+                        const pkgDescription = pkg['description'];
+                        const detectedPkg = {
+                            name: pkgName,
+                            path: relativePath,
+                            absolutePath: pkgDir,
+                            packageManager,
+                            language: this.detectLanguageFromPackage(pkg),
+                            internalDependencies: this.extractInternalDeps(pkg, packages),
+                            externalDependencies: this.extractExternalDeps(pkg),
+                            isRoot: false,
+                        };
+                        if (pkgVersion)
+                            detectedPkg.version = pkgVersion;
+                        if (pkgDescription)
+                            detectedPkg.description = pkgDescription;
+                        packages.push(detectedPkg);
+                        this.emitEvent('package:detected', pkgName);
+                    }
+                    catch {
+                        // Not a valid package
+                    }
+                }
+            }
+            catch {
+                // Directory doesn't exist
+            }
+        }
+        return packages;
+    }
+    detectLanguageFromPackage(pkg) {
+        const deps = {
+            ...(pkg['dependencies'] || {}),
+            ...(pkg['devDependencies'] || {}),
+        };
+        if (deps['typescript'] || deps['@types/node'])
+            return 'typescript';
+        if (deps['react'] || deps['vue'] || deps['@angular/core'])
+            return 'typescript';
+        return 'javascript';
+    }
+    extractInternalDeps(pkg, knownPackages) {
+        const deps = {
+            ...(pkg['dependencies'] || {}),
+            ...(pkg['devDependencies'] || {}),
+        };
+        const knownNames = new Set(knownPackages.map(p => p.name));
+        return Object.keys(deps).filter(dep => knownNames.has(dep));
+    }
+    extractExternalDeps(pkg) {
+        const deps = pkg['dependencies'] || {};
+        return Object.keys(deps).slice(0, 20);
+    }
+    // ===========================================================================
+    // Python Detection
+    // ===========================================================================
+    async detectPythonPackages() {
+        const packages = [];
+        try {
+            const pyprojectPath = path.join(this.rootDir, 'pyproject.toml');
+            const content = await fs.readFile(pyprojectPath, 'utf-8');
+            if (content.includes('[tool.poetry]')) {
+                const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+                const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
+                const detectedPkg = {
+                    name: nameMatch?.[1] || path.basename(this.rootDir),
+                    path: '.',
+                    absolutePath: this.rootDir,
+                    packageManager: 'poetry',
+                    language: 'python',
+                    internalDependencies: [],
+                    externalDependencies: this.extractPythonDeps(content),
+                    isRoot: true,
+                };
+                if (versionMatch?.[1])
+                    detectedPkg.version = versionMatch[1];
+                packages.push(detectedPkg);
+            }
+        }
+        catch {
+            // No pyproject.toml
+        }
+        try {
+            const srcPath = path.join(this.rootDir, 'src');
+            const entries = await fs.readdir(srcPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith('_')) {
+                    const initPath = path.join(srcPath, entry.name, '__init__.py');
+                    try {
+                        await fs.access(initPath);
+                        packages.push({
+                            name: entry.name,
+                            path: `src/${entry.name}`,
+                            absolutePath: path.join(srcPath, entry.name),
+                            packageManager: 'pip',
+                            language: 'python',
+                            internalDependencies: [],
+                            externalDependencies: [],
+                            isRoot: false,
+                        });
+                    }
+                    catch {
+                        // Not a Python package
+                    }
+                }
+            }
+        }
+        catch {
+            // No src directory
+        }
+        const pm = packages.length > 0 ? packages[0].packageManager : 'pip';
+        return { packages, packageManager: pm };
+    }
+    extractPythonDeps(content) {
+        const deps = [];
+        const depsMatch = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?:\[|$)/);
+        if (depsMatch?.[1]) {
+            const lines = depsMatch[1].split('\n');
+            for (const line of lines) {
+                const match = line.match(/^(\w[\w-]*)\s*=/);
+                if (match?.[1] && match[1] !== 'python') {
+                    deps.push(match[1]);
+                }
+            }
+        }
+        return deps.slice(0, 20);
+    }
+    // ===========================================================================
+    // Go Detection
+    // ===========================================================================
+    async detectGoModules() {
+        const packages = [];
+        try {
+            const goModPath = path.join(this.rootDir, 'go.mod');
+            const content = await fs.readFile(goModPath, 'utf-8');
+            const moduleMatch = content.match(/module\s+(\S+)/);
+            const moduleName = moduleMatch?.[1] || path.basename(this.rootDir);
+            packages.push({
+                name: moduleName,
+                path: '.',
+                absolutePath: this.rootDir,
+                packageManager: 'go',
+                language: 'go',
+                internalDependencies: [],
+                externalDependencies: this.extractGoDeps(content),
+                isRoot: true,
+            });
+            const internalDirs = ['internal', 'pkg', 'cmd'];
+            for (const dir of internalDirs) {
+                try {
+                    const dirPath = path.join(this.rootDir, dir);
+                    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            packages.push({
+                                name: `${moduleName}/${dir}/${entry.name}`,
+                                path: `${dir}/${entry.name}`,
+                                absolutePath: path.join(dirPath, entry.name),
+                                packageManager: 'go',
+                                language: 'go',
+                                internalDependencies: [],
+                                externalDependencies: [],
+                                isRoot: false,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Directory doesn't exist
+                }
+            }
+        }
+        catch {
+            // No go.mod
+        }
+        return { packages, packageManager: 'go' };
+    }
+    extractGoDeps(content) {
+        const deps = [];
+        const requireMatch = content.match(/require\s*\(([\s\S]*?)\)/);
+        if (requireMatch?.[1]) {
+            const lines = requireMatch[1].split('\n');
+            for (const line of lines) {
+                const match = line.match(/^\s*(\S+)\s+v/);
+                if (match?.[1]) {
+                    deps.push(match[1]);
+                }
+            }
+        }
+        return deps.slice(0, 20);
+    }
+    // ===========================================================================
+    // Java Detection (Maven/Gradle)
+    // ===========================================================================
+    async detectMavenModules() {
+        const packages = [];
+        try {
+            const pomPath = path.join(this.rootDir, 'pom.xml');
+            const content = await fs.readFile(pomPath, 'utf-8');
+            const artifactMatch = content.match(/<artifactId>([^<]+)<\/artifactId>/);
+            const groupMatch = content.match(/<groupId>([^<]+)<\/groupId>/);
+            const versionMatch = content.match(/<version>([^<]+)<\/version>/);
+            const detectedPkg = {
+                name: `${groupMatch?.[1] || 'unknown'}:${artifactMatch?.[1] || 'unknown'}`,
+                path: '.',
+                absolutePath: this.rootDir,
+                packageManager: 'maven',
+                language: 'java',
+                internalDependencies: [],
+                externalDependencies: [],
+                isRoot: true,
+            };
+            if (versionMatch?.[1])
+                detectedPkg.version = versionMatch[1];
+            packages.push(detectedPkg);
+            const modulesMatch = content.match(/<modules>([\s\S]*?)<\/modules>/);
+            if (modulesMatch?.[1]) {
+                const moduleMatches = modulesMatch[1].matchAll(/<module>([^<]+)<\/module>/g);
+                for (const match of moduleMatches) {
+                    if (match[1]) {
+                        packages.push({
+                            name: match[1],
+                            path: match[1],
+                            absolutePath: path.join(this.rootDir, match[1]),
+                            packageManager: 'maven',
+                            language: 'java',
+                            internalDependencies: [],
+                            externalDependencies: [],
+                            isRoot: false,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // No pom.xml
+        }
+        return { packages, packageManager: 'maven' };
+    }
+    async detectGradleModules() {
+        const packages = [];
+        try {
+            const settingsPath = path.join(this.rootDir, 'settings.gradle');
+            let content;
+            try {
+                content = await fs.readFile(settingsPath, 'utf-8');
+            }
+            catch {
+                content = await fs.readFile(path.join(this.rootDir, 'settings.gradle.kts'), 'utf-8');
+            }
+            const rootNameMatch = content.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+            packages.push({
+                name: rootNameMatch?.[1] || path.basename(this.rootDir),
+                path: '.',
+                absolutePath: this.rootDir,
+                packageManager: 'gradle',
+                language: 'java',
+                internalDependencies: [],
+                externalDependencies: [],
+                isRoot: true,
+            });
+            const includeMatches = content.matchAll(/include\s*\(?['"]([^'"]+)['"]\)?/g);
+            for (const match of includeMatches) {
+                if (match[1]) {
+                    const modulePath = match[1].replace(/:/g, '/');
+                    packages.push({
+                        name: match[1],
+                        path: modulePath,
+                        absolutePath: path.join(this.rootDir, modulePath),
+                        packageManager: 'gradle',
+                        language: 'java',
+                        internalDependencies: [],
+                        externalDependencies: [],
+                        isRoot: false,
+                    });
+                }
+            }
+        }
+        catch {
+            // No settings.gradle
+        }
+        return { packages, packageManager: 'gradle' };
+    }
+    // ===========================================================================
+    // PHP Detection
+    // ===========================================================================
+    async detectComposerPackages() {
+        const packages = [];
+        try {
+            const composerPath = path.join(this.rootDir, 'composer.json');
+            const content = await fs.readFile(composerPath, 'utf-8');
+            const composer = JSON.parse(content);
+            const detectedPkg = {
+                name: composer['name'] || path.basename(this.rootDir),
+                path: '.',
+                absolutePath: this.rootDir,
+                packageManager: 'composer',
+                language: 'php',
+                internalDependencies: [],
+                externalDependencies: Object.keys(composer['require'] || {}).slice(0, 20),
+                isRoot: true,
+            };
+            const version = composer['version'];
+            const description = composer['description'];
+            if (version)
+                detectedPkg.version = version;
+            if (description)
+                detectedPkg.description = description;
+            packages.push(detectedPkg);
+        }
+        catch {
+            // No composer.json
+        }
+        return { packages, packageManager: 'composer' };
+    }
+    // ===========================================================================
+    // .NET Detection
+    // ===========================================================================
+    async detectDotNetProjects() {
+        const packages = [];
+        try {
+            const entries = await fs.readdir(this.rootDir);
+            const slnFile = entries.find(e => e.endsWith('.sln'));
+            if (slnFile) {
+                const slnPath = path.join(this.rootDir, slnFile);
+                const content = await fs.readFile(slnPath, 'utf-8');
+                const projectMatches = content.matchAll(/Project\([^)]+\)\s*=\s*"([^"]+)",\s*"([^"]+)"/g);
+                for (const match of projectMatches) {
+                    const projectName = match[1];
+                    const projectPath = match[2]?.replace(/\\/g, '/');
+                    if (projectName && projectPath?.endsWith('.csproj')) {
+                        packages.push({
+                            name: projectName,
+                            path: path.dirname(projectPath),
+                            absolutePath: path.join(this.rootDir, path.dirname(projectPath)),
+                            packageManager: 'nuget',
+                            language: 'csharp',
+                            internalDependencies: [],
+                            externalDependencies: [],
+                            isRoot: packages.length === 0,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // No .sln file
+        }
+        return { packages, packageManager: 'nuget' };
+    }
+    // ===========================================================================
+    // Rust Detection
+    // ===========================================================================
+    async detectCargoWorkspaces() {
+        const packages = [];
+        try {
+            const cargoPath = path.join(this.rootDir, 'Cargo.toml');
+            const content = await fs.readFile(cargoPath, 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+            const versionMatch = content.match(/version\s*=\s*"([^"]+)"/);
+            const detectedPkg = {
+                name: nameMatch?.[1] || path.basename(this.rootDir),
+                path: '.',
+                absolutePath: this.rootDir,
+                packageManager: 'cargo',
+                language: 'rust',
+                internalDependencies: [],
+                externalDependencies: [],
+                isRoot: true,
+            };
+            if (versionMatch?.[1])
+                detectedPkg.version = versionMatch[1];
+            packages.push(detectedPkg);
+            const workspaceMatch = content.match(/\[workspace\]([\s\S]*?)(?:\[|$)/);
+            if (workspaceMatch?.[1]) {
+                const membersMatch = workspaceMatch[1].match(/members\s*=\s*\[([\s\S]*?)\]/);
+                if (membersMatch?.[1]) {
+                    const members = membersMatch[1].match(/"([^"]+)"/g) || [];
+                    for (const member of members) {
+                        const memberPath = member.replace(/"/g, '');
+                        packages.push({
+                            name: memberPath,
+                            path: memberPath,
+                            absolutePath: path.join(this.rootDir, memberPath),
+                            packageManager: 'cargo',
+                            language: 'rust',
+                            internalDependencies: [],
+                            externalDependencies: [],
+                            isRoot: false,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // No Cargo.toml
+        }
+        return { packages, packageManager: 'cargo' };
+    }
+    // ===========================================================================
+    // Root Package Detection
+    // ===========================================================================
+    async detectRootPackage() {
+        const manifests = [
+            { file: 'package.json', pm: 'npm' },
+            { file: 'pyproject.toml', pm: 'poetry' },
+            { file: 'setup.py', pm: 'pip' },
+            { file: 'Cargo.toml', pm: 'cargo' },
+            { file: 'go.mod', pm: 'go' },
+            { file: 'pom.xml', pm: 'maven' },
+            { file: 'build.gradle', pm: 'gradle' },
+            { file: 'composer.json', pm: 'composer' },
+        ];
+        for (const { file, pm } of manifests) {
+            try {
+                const manifestPath = path.join(this.rootDir, file);
+                await fs.access(manifestPath);
+                const content = await fs.readFile(manifestPath, 'utf-8');
+                let name = path.basename(this.rootDir);
+                let version;
+                let description;
+                if (file === 'package.json') {
+                    const pkg = JSON.parse(content);
+                    name = pkg['name'] || name;
+                    version = pkg['version'];
+                    description = pkg['description'];
+                }
+                const detectedPkg = {
+                    name,
+                    path: '.',
+                    absolutePath: this.rootDir,
+                    packageManager: pm,
+                    language: LANGUAGE_MAP[pm],
+                    internalDependencies: [],
+                    externalDependencies: [],
+                    isRoot: true,
+                };
+                if (version)
+                    detectedPkg.version = version;
+                if (description)
+                    detectedPkg.description = description;
+                return detectedPkg;
+            }
+            catch {
+                // Manifest doesn't exist
+            }
+        }
+        return null;
+    }
+    // ===========================================================================
+    // Events
+    // ===========================================================================
+    emitEvent(type, packageName, details) {
+        const event = {
+            type,
+            timestamp: new Date().toISOString(),
+        };
+        if (packageName)
+            event.packageName = packageName;
+        if (details)
+            event.details = details;
+        this.emit(type, event);
+        this.emit('*', event);
+    }
+}
+// =============================================================================
+// Factory Function
+// =============================================================================
+/**
+ * Create a package detector
+ */
+export function createPackageDetector(rootDir) {
+    return new PackageDetector(rootDir);
+}
+//# sourceMappingURL=package-detector.js.map