@principal-ai/codebase-composition 0.2.10 → 0.2.12

package/dist/modules/PackageLayerModule.js

@@ -0,0 +1,866 @@
+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);
+        // Extract author - can be string or object
+        let author;
+        if (content.author) {
+            if (typeof content.author === 'string') {
+                author = content.author;
+            }
+            else if (content.author.name) {
+                // Format: "Name <email> (url)"
+                let authorStr = content.author.name;
+                if (content.author.email)
+                    authorStr += ` <${content.author.email}>`;
+                if (content.author.url)
+                    authorStr += ` (${content.author.url})`;
+                author = authorStr;
+            }
+        }
+        // Extract repository URL - can be string or object
+        let repository;
+        if (content.repository) {
+            if (typeof content.repository === 'string') {
+                repository = content.repository;
+            }
+            else if (content.repository.url) {
+                repository = content.repository.url;
+            }
+        }
+        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 || {},
+            description: content.description,
+            license: content.license,
+            author,
+            repository,
+            homepage: content.homepage,
+            keywords: content.keywords,
+            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);
+        // Extract metadata - prefer Poetry format, fall back to PEP 621
+        const description = poetryData?.description || projectData?.description;
+        // License can be string or object in PEP 621
+        let license;
+        if (poetryData?.license) {
+            license = poetryData.license;
+        }
+        else if (projectData?.license) {
+            license = typeof projectData.license === 'string'
+                ? projectData.license
+                : projectData.license.text;
+        }
+        // Authors - Poetry uses strings like "Name <email>", PEP 621 uses objects
+        let authors;
+        let author;
+        if (poetryData?.authors && poetryData.authors.length > 0) {
+            authors = poetryData.authors;
+            author = poetryData.authors[0];
+        }
+        else if (projectData?.authors && projectData.authors.length > 0) {
+            authors = projectData.authors.map(a => {
+                if (a.name && a.email)
+                    return `${a.name} <${a.email}>`;
+                return a.name || a.email || '';
+            }).filter(Boolean);
+            author = authors[0];
+        }
+        // Repository/Homepage - Poetry has direct fields, PEP 621 uses urls table
+        let repository;
+        let homepage;
+        if (poetryData) {
+            repository = poetryData.repository;
+            homepage = poetryData.homepage;
+        }
+        else if (projectData?.urls) {
+            repository = projectData.urls.repository || projectData.urls.Repository ||
+                projectData.urls.source || projectData.urls.Source;
+            homepage = projectData.urls.homepage || projectData.urls.Homepage ||
+                projectData.urls.home || projectData.urls.Home;
+        }
+        const keywords = poetryData?.keywords || projectData?.keywords;
+        return {
+            name,
+            version,
+            path: packagePath,
+            manifestPath: path, // The full relative path to pyproject.toml/requirements.txt/setup.py
+            packageManager,
+            dependencies,
+            devDependencies,
+            peerDependencies: {},
+            description,
+            license,
+            author,
+            authors,
+            repository,
+            homepage,
+            keywords,
+            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);
+            });
+        }
+        // Extract metadata from [package] section
+        const author = packageData.authors?.[0];
+        // Prefer homepage over documentation URL for the homepage field
+        const homepage = packageData.homepage || packageData.documentation;
+        return {
+            name: packageData.name || 'unnamed',
+            version: packageData.version,
+            path: packagePath,
+            manifestPath: path, // The full relative path to Cargo.toml
+            packageManager: 'cargo',
+            dependencies,
+            devDependencies,
+            peerDependencies: {},
+            description: packageData.description,
+            license: packageData.license,
+            author,
+            authors: packageData.authors,
+            repository: packageData.repository,
+            homepage,
+            keywords: packageData.keywords,
+            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