@principal-ai/codebase-composition 0.2.8 → 0.2.10

package/dist/modules/PackageLayerModule.js

@@ -1,775 +0,0 @@
-import * as TOML from 'js-toml';
-import { parsePipRequirementsFile } from 'pip-requirements-js';
-import { QualityMetricsCalculator } from '../helpers/QualityMetricsCalculator.js';
-// Node.js package.json parser
-class NodePackageParser {
-    manifestFileName = 'package.json';
-    packageType = 'node';
-    canParse(filename) {
-        return filename.endsWith('package.json');
-    }
-    parseContent(rawContent) {
-        try {
-            return JSON.parse(rawContent);
-        }
-        catch {
-            return null;
-        }
-    }
-    extractPackageData(content, path) {
-        // Handle cases where path is just "package.json" (root package)
-        // or a proper path like "packages/foo/package.json"
-        let packagePath;
-        if (path === 'package.json') {
-            packagePath = ''; // Root directory - empty string for root
-        }
-        else if (path.endsWith('/package.json')) {
-            packagePath = path.slice(0, -13); // Remove '/package.json'
-        }
-        else {
-            // Shouldn't happen, but handle gracefully
-            packagePath = path;
-        }
-        const availableCommands = this.extractCommands(content, packagePath);
-        return {
-            name: content.name || 'unnamed',
-            version: content.version,
-            path: packagePath,
-            manifestPath: path, // The full relative path to package.json
-            packageManager: 'unknown',
-            dependencies: content.dependencies || {},
-            devDependencies: content.devDependencies || {},
-            peerDependencies: content.peerDependencies || {},
-            isMonorepoRoot: !!content.workspaces,
-            isWorkspace: false, // Will be determined by context
-            parentPackage: undefined,
-            availableCommands,
-        };
-    }
-    extractCommands(content, packagePath) {
-        const commands = [];
-        // Extract npm scripts
-        if (content.scripts) {
-            Object.entries(content.scripts).forEach(([name, script]) => {
-                // Use npm as default, will be updated with correct package manager later
-                commands.push({
-                    name,
-                    command: `npm run ${name}`,
-                    description: script.length > 50 ? script.substring(0, 47) + '...' : script,
-                    type: 'script',
-                    workingDirectory: packagePath,
-                });
-            });
-        }
-        // Add standard npm commands - these will also be updated with correct package manager
-        const standardCommands = [
-            { name: 'install', command: 'npm install', description: 'Install dependencies' },
-            { name: 'ci', command: 'npm ci', description: 'Clean install dependencies' },
-            { name: 'update', command: 'npm update', description: 'Update dependencies' },
-        ];
-        standardCommands.forEach(cmd => {
-            commands.push({
-                ...cmd,
-                type: 'standard',
-                workingDirectory: packagePath,
-            });
-        });
-        return commands;
-    }
-    detectWorkspaces(content) {
-        if (Array.isArray(content.workspaces)) {
-            return content.workspaces;
-        }
-        if (content.workspaces &&
-            typeof content.workspaces === 'object' &&
-            'packages' in content.workspaces) {
-            return content.workspaces.packages || null;
-        }
-        return null;
-    }
-    detectPackageManager(content, lockFiles) {
-        // Check for packageManager field (corepack)
-        if (content.packageManager) {
-            const pm = content.packageManager.split('@')[0];
-            if (['npm', 'yarn', 'pnpm'].includes(pm)) {
-                return pm;
-            }
-        }
-        // Check lock files
-        if (lockFiles.some((f) => f.endsWith('yarn.lock')))
-            return 'yarn';
-        if (lockFiles.some((f) => f.endsWith('pnpm-lock.yaml')))
-            return 'pnpm';
-        if (lockFiles.some((f) => f.endsWith('package-lock.json')))
-            return 'npm';
-        // Default to npm instead of unknown for Node packages
-        return 'npm';
-    }
-    detectConfigs(packagePath, fileTree, manifestContent) {
-        const configs = {};
-        // Define config patterns for Node/JavaScript projects
-        const configPatterns = {
-            knip: [
-                'knip.json',
-                'knip.jsonc',
-                '.knip.json',
-                'knip.config.js',
-                'knip.config.ts',
-                'knip.config.mjs',
-            ],
-            eslint: [
-                '.eslintrc',
-                '.eslintrc.js',
-                '.eslintrc.json',
-                '.eslintrc.yml',
-                '.eslintrc.yaml',
-                'eslint.config.js',
-                'eslint.config.mjs',
-                '.eslintrc.cjs',
-            ],
-            prettier: [
-                '.prettierrc',
-                '.prettierrc.js',
-                '.prettierrc.json',
-                '.prettierrc.yml',
-                '.prettierrc.yaml',
-                'prettier.config.js',
-                '.prettierrc.toml',
-            ],
-            typescript: ['tsconfig.json', 'tsconfig.base.json'],
-            jest: [
-                'jest.config.js',
-                'jest.config.ts',
-                'jest.config.mjs',
-                'jest.config.cjs',
-                'jest.config.json',
-            ],
-            vitest: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'],
-            webpack: ['webpack.config.js', 'webpack.config.ts', 'webpack.config.mjs'],
-            vite: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
-            rollup: ['rollup.config.js', 'rollup.config.ts', 'rollup.config.mjs'],
-            babel: ['.babelrc', '.babelrc.js', '.babelrc.json', 'babel.config.js', 'babel.config.json'],
-            dockerfile: ['Dockerfile', 'dockerfile', 'Dockerfile.dev', 'Dockerfile.prod'],
-            gitignore: ['.gitignore'],
-            editorconfig: ['.editorconfig'],
-        };
-        // Normalize package path
-        const normalizedPath = packagePath === '.' || packagePath === ''
-            ? ''
-            : packagePath.endsWith('/')
-                ? packagePath
-                : packagePath + '/';
-        // Check files in tree
-        if (fileTree.allFiles) {
-            for (const [tool, patterns] of Object.entries(configPatterns)) {
-                for (const pattern of patterns) {
-                    const fullPath = normalizedPath + pattern;
-                    const fileExists = fileTree.allFiles.some(f => f.path === fullPath || f.relativePath === fullPath);
-                    if (fileExists) {
-                        configs[tool] = {
-                            path: fullPath,
-                            exists: true,
-                            type: this.getConfigFileType(pattern),
-                        };
-                        break; // Found config for this tool
-                    }
-                }
-            }
-        }
-        // Check for inline configs in package.json
-        if (manifestContent) {
-            if (manifestContent.eslintConfig) {
-                configs.eslint = {
-                    path: normalizedPath + 'package.json',
-                    exists: true,
-                    type: 'json',
-                    isInline: true,
-                    inlineField: 'eslintConfig',
-                };
-            }
-            if (manifestContent.prettier) {
-                configs.prettier = {
-                    path: normalizedPath + 'package.json',
-                    exists: true,
-                    type: 'json',
-                    isInline: true,
-                    inlineField: 'prettier',
-                };
-            }
-            if (manifestContent.jest) {
-                configs.jest = {
-                    path: normalizedPath + 'package.json',
-                    exists: true,
-                    type: 'json',
-                    isInline: true,
-                    inlineField: 'jest',
-                };
-            }
-            if (manifestContent.babel) {
-                configs.babel = {
-                    path: normalizedPath + 'package.json',
-                    exists: true,
-                    type: 'json',
-                    isInline: true,
-                    inlineField: 'babel',
-                };
-            }
-        }
-        return configs;
-    }
-    getConfigFileType(filename) {
-        if (filename.endsWith('.json') || filename.endsWith('.jsonc'))
-            return 'json';
-        if (filename.endsWith('.yml') || filename.endsWith('.yaml'))
-            return 'yaml';
-        if (filename.endsWith('.toml'))
-            return 'toml';
-        if (filename.endsWith('.js') || filename.endsWith('.mjs') || filename.endsWith('.cjs'))
-            return 'js';
-        if (filename.endsWith('.ts') || filename.endsWith('.mts') || filename.endsWith('.cts'))
-            return 'ts';
-        if (filename.endsWith('.ini'))
-            return 'ini';
-        return 'custom';
-    }
-    detectDocsFolder(packagePath, fileTree, _manifestContent) {
-        // Look for common documentation folder names
-        const docsFolderNames = ['docs', 'documentation', 'doc'];
-        // Normalize package path
-        let packagePrefix = packagePath === '.' || packagePath === '' ? '' : packagePath;
-        if (packagePrefix && !packagePrefix.endsWith('/')) {
-            packagePrefix += '/';
-        }
-        if (!fileTree.allFiles)
-            return undefined;
-        // Look for root-level docs folders first (preferred)
-        for (const folderName of docsFolderNames) {
-            const expectedPath = packagePrefix + folderName;
-            const hasFiles = fileTree.allFiles.some(file => file.path?.toLowerCase().startsWith(expectedPath.toLowerCase() + '/'));
-            if (hasFiles) {
-                // Find the actual folder name with correct case
-                const actualPath = fileTree.allFiles.find(file => file.path?.toLowerCase().startsWith(expectedPath.toLowerCase() + '/'))?.path;
-                if (actualPath) {
-                    const actualFolderPath = actualPath.substring(0, actualPath.indexOf('/', packagePrefix.length));
-                    return actualFolderPath.substring(packagePrefix.length);
-                }
-                return folderName; // Fallback to lowercase version
-            }
-        }
-        // If no explicit docs folder found, look for directories with high concentration of docs
-        const potentialFolders = new Map();
-        for (const file of fileTree.allFiles) {
-            if (!file.path)
-                continue;
-            // Only consider files within this package
-            if (packagePrefix !== '' && !file.path.startsWith(packagePrefix)) {
-                continue;
-            }
-            const relativePath = packagePrefix === '' ? file.path : file.path.substring(packagePrefix.length);
-            const pathParts = relativePath.split('/');
-            // Only look at direct subdirectories (depth 1)
-            if (pathParts.length === 2) {
-                const dirName = pathParts[0];
-                const fileName = pathParts[1];
-                if (!potentialFolders.has(dirName)) {
-                    potentialFolders.set(dirName, { docFiles: 0, totalFiles: 0 });
-                }
-                const stats = potentialFolders.get(dirName);
-                stats.totalFiles++;
-                if (this.isDocumentationFile(fileName)) {
-                    stats.docFiles++;
-                }
-            }
-        }
-        // Find the best candidate folder (highest percentage of docs, minimum 2 doc files)
-        let bestFolder;
-        let bestScore = 0.5; // Must be at least 50% docs
-        for (const [folderName, stats] of Array.from(potentialFolders.entries())) {
-            if (stats.docFiles >= 2) {
-                const score = stats.docFiles / stats.totalFiles;
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestFolder = folderName;
-                }
-            }
-        }
-        return bestFolder;
-    }
-    isDocumentationFile(fileName) {
-        const lowerName = fileName.toLowerCase();
-        // Documentation file extensions
-        const docExtensions = ['.md', '.mdx', '.rst', '.txt', '.adoc', '.asciidoc'];
-        const hasDocExtension = docExtensions.some(ext => lowerName.endsWith(ext));
-        if (hasDocExtension)
-            return true;
-        // Documentation file name patterns
-        const docPatterns = [
-            /^readme/i,
-            /^changelog/i,
-            /^changes/i,
-            /^history/i,
-            /^license/i,
-            /^copying/i,
-            /^install/i,
-            /^usage/i,
-            /^guide/i,
-            /^tutorial/i,
-            /^manual/i,
-            /^faq/i,
-            /^api/i,
-            /^reference/i,
-            /^spec/i,
-            /^specification/i,
-        ];
-        return docPatterns.some(pattern => pattern.test(fileName));
-    }
-}
-// Python pyproject.toml parser - simplified version
-class PythonPackageParser {
-    manifestFileName = 'pyproject.toml';
-    packageType = 'python';
-    canParse(filename) {
-        return (filename.endsWith('pyproject.toml') ||
-            filename.endsWith('setup.py') ||
-            filename.endsWith('requirements.txt'));
-    }
-    parseContent(rawContent) {
-        try {
-            return TOML.load(rawContent);
-        }
-        catch {
-            return null;
-        }
-    }
-    extractPackageData(content, path) {
-        // Extract package directory path from manifest path
-        let packagePath;
-        const manifestName = path.split('/').pop() || '';
-        if (path === manifestName) {
-            // Just the filename, package is at root
-            packagePath = ''; // Empty string for root
-        }
-        else {
-            // Remove the manifest filename from path
-            packagePath = path.substring(0, path.lastIndexOf('/'));
-        }
-        // Handle pyproject.toml structure
-        const poetryData = content.tool?.poetry;
-        const projectData = content.project;
-        const name = poetryData?.name || projectData?.name || 'unnamed';
-        const version = poetryData?.version || projectData?.version;
-        // Extract dependencies
-        const dependencies = {};
-        const devDependencies = {};
-        // Poetry format
-        if (poetryData?.dependencies) {
-            Object.entries(poetryData.dependencies).forEach(([key, value]) => {
-                if (key !== 'python') {
-                    dependencies[key] = typeof value === 'string' ? value : JSON.stringify(value);
-                }
-            });
-        }
-        if (poetryData?.['dev-dependencies']) {
-            Object.entries(poetryData['dev-dependencies']).forEach(([key, value]) => {
-                devDependencies[key] = typeof value === 'string' ? value : JSON.stringify(value);
-            });
-        }
-        // PEP 621 format
-        if (projectData?.dependencies && Array.isArray(projectData.dependencies)) {
-            try {
-                // Use pip-requirements-js to properly parse PEP 508 dependency specifications
-                const depString = projectData.dependencies.join('\n');
-                const requirements = parsePipRequirementsFile(depString);
-                requirements.forEach((req) => {
-                    if (req.type === 'ProjectName' && req.name) {
-                        let version = '*';
-                        if (req.versionSpec && req.versionSpec.length > 0) {
-                            // Use the first version spec for simplicity
-                            const firstSpec = req.versionSpec[0];
-                            version = firstSpec.version || '*';
-                        }
-                        dependencies[req.name] = version;
-                    }
-                });
-            }
-            catch (error) {
-                console.warn('Failed to parse PEP 621 dependencies with pip-requirements-js, falling back to simple parsing:', error);
-                // Fallback to simple parsing if pip-requirements-js fails
-                projectData.dependencies.forEach((dep) => {
-                    const cleanDep = dep.trim();
-                    const spaceIndex = cleanDep.indexOf(' ');
-                    if (spaceIndex > 0) {
-                        dependencies[cleanDep.substring(0, spaceIndex)] = '*';
-                    }
-                    else {
-                        dependencies[cleanDep] = '*';
-                    }
-                });
-            }
-        }
-        const packageManager = this.detectPythonPackageManager(content);
-        return {
-            name,
-            version,
-            path: packagePath,
-            manifestPath: path, // The full relative path to pyproject.toml/requirements.txt/setup.py
-            packageManager,
-            dependencies,
-            devDependencies,
-            peerDependencies: {},
-            isMonorepoRoot: false,
-            isWorkspace: false,
-            parentPackage: undefined,
-            availableCommands: [],
-        };
-    }
-    detectWorkspaces(_content) {
-        // Python doesn't have built-in workspace support like npm
-        return null;
-    }
-    detectPackageManager(content, _lockFiles) {
-        return this.detectPythonPackageManager(content);
-    }
-    detectPythonPackageManager(content) {
-        // Check for Poetry
-        if (content.tool?.poetry)
-            return 'poetry';
-        // Default to pip
-        return 'pip';
-    }
-    detectDocsFolder(packagePath, fileTree, _manifestContent) {
-        // Reuse the same logic as NodePackageParser
-        const nodeParser = new NodePackageParser();
-        return nodeParser.detectDocsFolder(packagePath, fileTree, {});
-    }
-}
-// Rust Cargo.toml parser - simplified version
-class CargoPackageParser {
-    manifestFileName = 'Cargo.toml';
-    packageType = 'cargo';
-    canParse(filename) {
-        return filename.endsWith('Cargo.toml');
-    }
-    parseContent(rawContent) {
-        try {
-            return TOML.load(rawContent);
-        }
-        catch {
-            return null;
-        }
-    }
-    extractPackageData(content, path) {
-        const packageData = content.package;
-        if (!packageData)
-            return null;
-        // Extract package directory path from manifest path
-        let packagePath;
-        if (path === 'Cargo.toml') {
-            packagePath = ''; // Root directory - empty string for root
-        }
-        else if (path.endsWith('/Cargo.toml')) {
-            packagePath = path.slice(0, -11); // Remove '/Cargo.toml'
-        }
-        else {
-            // Shouldn't happen, but handle gracefully
-            packagePath = path;
-        }
-        // Extract dependencies
-        const dependencies = {};
-        const devDependencies = {};
-        if (content.dependencies) {
-            Object.entries(content.dependencies).forEach(([key, value]) => {
-                dependencies[key] = typeof value === 'string' ? value : JSON.stringify(value);
-            });
-        }
-        if (content['dev-dependencies']) {
-            Object.entries(content['dev-dependencies']).forEach(([key, value]) => {
-                devDependencies[key] = typeof value === 'string' ? value : JSON.stringify(value);
-            });
-        }
-        return {
-            name: packageData.name || 'unnamed',
-            version: packageData.version,
-            path: packagePath,
-            manifestPath: path, // The full relative path to Cargo.toml
-            packageManager: 'cargo',
-            dependencies,
-            devDependencies,
-            peerDependencies: {},
-            isMonorepoRoot: !!content.workspace,
-            isWorkspace: false,
-            parentPackage: undefined,
-            availableCommands: [],
-        };
-    }
-    detectWorkspaces(content) {
-        return content.workspace?.members || null;
-    }
-    detectPackageManager() {
-        return 'cargo';
-    }
-    detectDocsFolder(packagePath, fileTree, _manifestContent) {
-        // Reuse the same logic as NodePackageParser
-        const nodeParser = new NodePackageParser();
-        return nodeParser.detectDocsFolder(packagePath, fileTree, {});
-    }
-}
-export class PackageLayerModule {
-    parsers = [
-        new NodePackageParser(),
-        new PythonPackageParser(),
-        new CargoPackageParser(),
-    ];
-    /**
-     * Extract package information from the file tree
-     * @param fileTree - The file tree to analyze
-     * @param fileReader - Optional function to read file contents. If not provided, manifest detection only.
-     */
-    async discoverPackages(fileTree, fileReader) {
-        const packages = [];
-        if (!fileTree.allFiles)
-            return packages;
-        // Find all package manifest files
-        const manifestFiles = fileTree.allFiles.filter(file => {
-            if (!file.path)
-                return false;
-            return this.parsers.some(parser => parser.canParse(file.path));
-        });
-        // Get all files for lock file detection
-        const allFilePaths = fileTree.allFiles.map(f => f.path).filter(Boolean);
-        for (const manifestFile of manifestFiles) {
-            if (!manifestFile.path)
-                continue;
-            // Find appropriate parser
-            const parser = this.parsers.find(p => p.canParse(manifestFile.path));
-            if (!parser)
-                continue;
-            // Get manifest content
-            let content = null;
-            if (fileReader) {
-                try {
-                    const fileContent = await fileReader(manifestFile.path);
-                    if (fileContent) {
-                        // Use the parser's parseContent method for type-safe parsing
-                        content = parser.parseContent(fileContent);
-                    }
-                }
-                catch (error) {
-                    console.warn(`Could not read or parse ${manifestFile.path}:`, error);
-                    continue;
-                }
-            }
-            else {
-                // If no file reader provided, create minimal package info from path
-                const packageName = manifestFile.path.split('/').slice(-2, -1)[0] || 'unnamed';
-                content = this.createMinimalManifest(parser.packageType, packageName);
-            }
-            if (!content)
-                continue;
-            // Extract package data
-            const packageData = parser.extractPackageData(content, manifestFile.path);
-            if (!packageData) {
-                console.warn(`[PackageLayerModule] extractPackageData returned null for ${manifestFile.path}`, { content, parser: parser.packageType });
-                continue;
-            }
-            // Detect package manager
-            const dirPath = manifestFile.path.substring(0, manifestFile.path.lastIndexOf('/'));
-            const lockFilesInDir = allFilePaths.filter(f => f.startsWith(dirPath) && this.isLockFile(f));
-            packageData.packageManager = parser.detectPackageManager(content, lockFilesInDir);
-            // Update commands with correct package manager for Node packages
-            if (parser.packageType === 'node' && packageData.availableCommands) {
-                // Only replace if we detected a valid package manager
-                if (packageData.packageManager &&
-                    packageData.packageManager !== 'unknown' &&
-                    packageData.packageManager !== 'npm') {
-                    packageData.availableCommands = packageData.availableCommands.map(cmd => {
-                        // Update both script and standard commands
-                        if (cmd.command.includes('npm ')) {
-                            let pmCommand = cmd.command;
-                            // Handle different package manager syntaxes
-                            if (packageData.packageManager === 'yarn') {
-                                pmCommand = pmCommand
-                                    .replace('npm run', 'yarn')
-                                    .replace('npm install', 'yarn install')
-                                    .replace('npm ci', 'yarn install --frozen-lockfile')
-                                    .replace('npm update', 'yarn upgrade');
-                            }
-                            else if (packageData.packageManager === 'pnpm') {
-                                pmCommand = pmCommand.replace('npm', 'pnpm');
-                            }
-                            return { ...cmd, command: pmCommand };
-                        }
-                        return cmd;
-                    });
-                }
-            }
-            // Create file set for the manifest
-            const fileSet = {
-                id: `package-manifest-${packageData.path}`,
-                name: parser.manifestFileName,
-                patterns: [
-                    {
-                        type: 'exact',
-                        pattern: manifestFile.path,
-                        description: `${parser.packageType} package manifest`,
-                    },
-                ],
-                matchedFiles: [manifestFile.path],
-                fileCount: 1,
-            };
-            // Detect configuration files if the parser supports it
-            let configFiles;
-            if (parser.detectConfigs) {
-                configFiles = parser.detectConfigs(packageData.path, fileTree, content);
-            }
-            // Detect documentation folder if the parser supports it
-            let docsFolder;
-            if (parser.detectDocsFolder) {
-                docsFolder = parser.detectDocsFolder(packageData.path, fileTree, content);
-            }
-            // Calculate quality metrics from lens commands
-            const qualityMetrics = packageData.availableCommands
-                ? QualityMetricsCalculator.calculateQualityProfile(packageData.availableCommands)
-                : undefined;
-            // Create package layer
-            const layer = {
-                id: `package-${parser.packageType}-${packageData.path.replace(/[^a-zA-Z0-9-]/g, '-')}`,
-                name: packageData.name,
-                type: parser.packageType,
-                enabled: true,
-                derivedFrom: {
-                    fileSets: [fileSet],
-                    derivationType: 'content',
-                    description: `${parser.packageType} package defined in ${parser.manifestFileName}`,
-                    contentExtraction: {
-                        method: 'parse',
-                        parser: {
-                            format: parser.manifestFileName.endsWith('.json') ? 'json' : 'toml',
-                            paths: parser.packageType === 'node'
-                                ? ['']
-                                : parser.packageType === 'python'
-                                    ? ['tool.poetry', 'project']
-                                    : ['package'],
-                        },
-                    },
-                },
-                packageData,
-                configFiles,
-                docsFolder,
-                qualityMetrics,
-                pillar: 'foundationHealth',
-            };
-            packages.push(layer);
-        }
-        // Determine workspace relationships
-        this.resolveWorkspaceRelationships(packages);
-        return packages;
-    }
-    /**
-     * Create package layers from workspace boundaries (backwards compatibility)
-     */
-    createPackageLayersFromBoundaries(boundaries) {
-        return boundaries.map(boundary => {
-            const fileSet = {
-                id: `package-manifest-${boundary.rootPath || 'root'}`,
-                name: 'package.json',
-                patterns: [
-                    {
-                        type: 'exact',
-                        pattern: boundary.packageJsonPath,
-                        description: 'Node.js package manifest',
-                    },
-                ],
-                matchedFiles: [boundary.packageJsonPath],
-                fileCount: 1,
-            };
-            const packageData = {
-                name: boundary.packageData?.name || boundary.name,
-                version: boundary.packageData?.version,
-                path: boundary.rootPath || '.',
-                manifestPath: boundary.packageJsonPath,
-                packageManager: 'unknown',
-                dependencies: {},
-                devDependencies: {},
-                peerDependencies: {},
-                isMonorepoRoot: !!boundary.packageData?.workspaces,
-                isWorkspace: !boundary.isRoot && boundaries.length > 1,
-                parentPackage: boundary.isRoot ? undefined : 'root',
-            };
-            const layer = {
-                id: `package-node-${boundary.id}`,
-                name: packageData.name,
-                type: 'node',
-                enabled: true,
-                derivedFrom: {
-                    fileSets: [fileSet],
-                    derivationType: 'content',
-                    description: 'Node.js package defined in package.json',
-                },
-                packageData,
-                pillar: 'foundationHealth',
-            };
-            return layer;
-        });
-    }
-    isLockFile(path) {
-        const lockFiles = [
-            'package-lock.json',
-            'yarn.lock',
-            'pnpm-lock.yaml',
-            'poetry.lock',
-            'Pipfile.lock',
-            'Cargo.lock',
-        ];
-        return lockFiles.some(lock => path.endsWith(lock));
-    }
-    resolveWorkspaceRelationships(packages) {
-        // Find root packages (typically at the repository root)
-        const _rootPackages = packages.filter(p => p.packageData.path === '.' || p.packageData.path === '');
-        // Mark workspace packages
-        packages.forEach(pkg => {
-            if (pkg.packageData.path !== '.' && pkg.packageData.path !== '') {
-                pkg.packageData.isWorkspace = true;
-                // Find parent package
-                const parentPath = pkg.packageData.path.includes('/')
-                    ? pkg.packageData.path.substring(0, pkg.packageData.path.lastIndexOf('/'))
-                    : '.';
-                const parent = packages.find(p => p.packageData.path === parentPath);
-                if (parent) {
-                    pkg.packageData.parentPackage = parent.packageData.name;
-                }
-            }
-        });
-    }
-    /**
-     * Create a minimal manifest for when file content isn't available
-     */
-    createMinimalManifest(packageType, packageName) {
-        switch (packageType) {
-            case 'node':
-                return {
-                    name: packageName,
-                    version: '0.0.0',
-                    dependencies: {},
-                    devDependencies: {},
-                };
-            case 'python':
-                return {
-                    project: {
-                        name: packageName,
-                        version: '0.0.0',
-                    },
-                };
-            case 'cargo':
-                return {
-                    package: {
-                        name: packageName,
-                        version: '0.0.0',
-                    },
-                };
-            default:
-                return {};
-        }
-    }
-}
-//# sourceMappingURL=PackageLayerModule.js.map