@principal-ai/codebase-composition 0.1.0

package/src/modules/PackageLayerModule.ts

@@ -0,0 +1,979 @@
+import * as TOML from 'js-toml';
+import { parsePipRequirementsFile, Requirement } from 'pip-requirements-js';
+
+import { FileTree } from '@principal-ai/repository-abstraction';
+import { PackageLayer, FileSet, PackageCommand, ConfigFile } from '../types/layer-types';
+import { WorkspaceBoundary } from '../types/workspace-boundaries';
+
+// Type aliases for configuration objects
+type ESLintConfig = unknown;
+type PrettierConfig = unknown;
+type JestConfig = unknown;
+type BabelConfig = unknown;
+
+// Dependency value types
+type DependencyObject = {
+  version?: string;
+  [key: string]: unknown;
+};
+type DependencyValue = string | DependencyObject;
+
+// Package manifest types
+type PackageManifest = NodePackageJson | PyProjectToml | CargoToml;
+
+interface NodePackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+  workspaces?: string[] | { packages: string[] };
+  packageManager?: string;
+  eslintConfig?: ESLintConfig;
+  prettier?: PrettierConfig;
+  jest?: JestConfig;
+  babel?: BabelConfig;
+}
+
+interface PyProjectToml {
+  tool?: {
+    poetry?: {
+      name?: string;
+      version?: string;
+      dependencies?: Record<string, DependencyValue>;
+      'dev-dependencies'?: Record<string, DependencyValue>;
+    };
+  };
+  project?: {
+    name?: string;
+    version?: string;
+    dependencies?: string[];
+  };
+}
+
+interface CargoToml {
+  package?: {
+    name?: string;
+    version?: string;
+  };
+  dependencies?: Record<string, DependencyValue>;
+  'dev-dependencies'?: Record<string, DependencyValue>;
+  workspace?: {
+    members?: string[];
+  };
+}
+
+// Generic parser interface
+interface PackageManifestParser<T> {
+  manifestFileName: string;
+  packageType: 'node' | 'python' | 'cargo';
+
+  canParse(filename: string): boolean;
+  parseContent(rawContent: string): T | null;
+  extractPackageData(content: T, path: string): PackageLayer['packageData'] | null;
+  detectWorkspaces(content: T): string[] | null;
+  detectPackageManager(content: T, lockFiles: string[]): string;
+  detectConfigs?(
+    packagePath: string,
+    fileTree: FileTree,
+    manifestContent: T,
+  ): PackageLayer['configFiles'];
+  detectDocsFolder?(
+    packagePath: string,
+    fileTree: FileTree,
+    manifestContent: T,
+  ): string | undefined;
+}
+
+// Node.js package.json parser
+class NodePackageParser implements PackageManifestParser<NodePackageJson> {
+  manifestFileName = 'package.json';
+  packageType = 'node' as const;
+
+  canParse(filename: string): boolean {
+    return filename.endsWith('package.json');
+  }
+
+  parseContent(rawContent: string): NodePackageJson | null {
+    try {
+      return JSON.parse(rawContent) as NodePackageJson;
+    } catch {
+      return null;
+    }
+  }
+
+  extractPackageData(content: NodePackageJson, path: string): PackageLayer['packageData'] | null {
+    // Handle cases where path is just "package.json" (root package)
+    // or a proper path like "packages/foo/package.json"
+    let packagePath: string;
+    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,
+      packageManager: 'unknown' as const,
+      dependencies: content.dependencies || {},
+      devDependencies: content.devDependencies || {},
+      peerDependencies: content.peerDependencies || {},
+      isMonorepoRoot: !!content.workspaces,
+      isWorkspace: false, // Will be determined by context
+      parentPackage: undefined,
+      availableCommands,
+    };
+  }
+
+  private extractCommands(content: NodePackageJson, packagePath: string): PackageCommand[] {
+    const commands: PackageCommand[] = [];
+
+    // 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: NodePackageJson): string[] | null {
+    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: NodePackageJson, lockFiles: string[]): string {
+    // 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: string) => f.endsWith('yarn.lock'))) return 'yarn';
+    if (lockFiles.some((f: string) => f.endsWith('pnpm-lock.yaml'))) return 'pnpm';
+    if (lockFiles.some((f: string) => f.endsWith('package-lock.json'))) return 'npm';
+
+    // Default to npm instead of unknown for Node packages
+    return 'npm';
+  }
+
+  detectConfigs(
+    packagePath: string,
+    fileTree: FileTree,
+    manifestContent: NodePackageJson,
+  ): PackageLayer['configFiles'] {
+    const configs: PackageLayer['configFiles'] = {};
+
+    // Define config patterns for Node/JavaScript projects
+    const configPatterns: Record<string, string[]> = {
+      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;
+  }
+
+  private getConfigFileType(filename: string): ConfigFile['type'] {
+    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: string,
+    fileTree: FileTree,
+    _manifestContent: NodePackageJson,
+  ): string | undefined {
+    // 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<string, { docFiles: number; totalFiles: number }>();
+
+    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: string | undefined;
+    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;
+  }
+
+  private isDocumentationFile(fileName: string): boolean {
+    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 implements PackageManifestParser<PyProjectToml> {
+  manifestFileName = 'pyproject.toml';
+  packageType = 'python' as const;
+
+  canParse(filename: string): boolean {
+    return (
+      filename.endsWith('pyproject.toml') ||
+      filename.endsWith('setup.py') ||
+      filename.endsWith('requirements.txt')
+    );
+  }
+
+  parseContent(rawContent: string): PyProjectToml | null {
+    try {
+      return TOML.load(rawContent) as PyProjectToml;
+    } catch {
+      return null;
+    }
+  }
+
+  extractPackageData(content: PyProjectToml, path: string): PackageLayer['packageData'] | null {
+    // Extract package directory path from manifest path
+    let packagePath: string;
+    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: Record<string, string> = {};
+    const devDependencies: Record<string, string> = {};
+
+    // 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: Requirement) => {
+          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: string) => {
+          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,
+      packageManager,
+      dependencies,
+      devDependencies,
+      peerDependencies: {},
+      isMonorepoRoot: false,
+      isWorkspace: false,
+      parentPackage: undefined,
+      availableCommands: [],
+    };
+  }
+
+  detectWorkspaces(_content: PyProjectToml): string[] | null {
+    // Python doesn't have built-in workspace support like npm
+    return null;
+  }
+
+  detectPackageManager(content: PyProjectToml, _lockFiles: string[]): string {
+    return this.detectPythonPackageManager(content);
+  }
+
+  private detectPythonPackageManager(
+    content: PyProjectToml,
+  ): 'pip' | 'poetry' | 'pipenv' | 'unknown' {
+    // Check for Poetry
+    if (content.tool?.poetry) return 'poetry';
+
+    // Default to pip
+    return 'pip';
+  }
+
+  detectDocsFolder(
+    packagePath: string,
+    fileTree: FileTree,
+    _manifestContent: PyProjectToml,
+  ): string | undefined {
+    // Reuse the same logic as NodePackageParser
+    const nodeParser = new NodePackageParser();
+    return nodeParser.detectDocsFolder(packagePath, fileTree, {} as NodePackageJson);
+  }
+}
+
+// Rust Cargo.toml parser - simplified version
+class CargoPackageParser implements PackageManifestParser<CargoToml> {
+  manifestFileName = 'Cargo.toml';
+  packageType = 'cargo' as const;
+
+  canParse(filename: string): boolean {
+    return filename.endsWith('Cargo.toml');
+  }
+
+  parseContent(rawContent: string): CargoToml | null {
+    try {
+      return TOML.load(rawContent) as CargoToml;
+    } catch {
+      return null;
+    }
+  }
+
+  extractPackageData(content: CargoToml, path: string): PackageLayer['packageData'] | null {
+    const packageData = content.package;
+    if (!packageData) return null;
+
+    // Extract package directory path from manifest path
+    let packagePath: string;
+    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: Record<string, string> = {};
+    const devDependencies: Record<string, string> = {};
+
+    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,
+      packageManager: 'cargo' as const,
+      dependencies,
+      devDependencies,
+      peerDependencies: {},
+      isMonorepoRoot: !!content.workspace,
+      isWorkspace: false,
+      parentPackage: undefined,
+      availableCommands: [],
+    };
+  }
+
+  detectWorkspaces(content: CargoToml): string[] | null {
+    return content.workspace?.members || null;
+  }
+
+  detectPackageManager(): string {
+    return 'cargo';
+  }
+
+  detectDocsFolder(
+    packagePath: string,
+    fileTree: FileTree,
+    _manifestContent: CargoToml,
+  ): string | undefined {
+    // Reuse the same logic as NodePackageParser
+    const nodeParser = new NodePackageParser();
+    return nodeParser.detectDocsFolder(packagePath, fileTree, {} as NodePackageJson);
+  }
+}
+
+export class PackageLayerModule {
+  private parsers: PackageManifestParser<PackageManifest>[] = [
+    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: FileTree,
+    fileReader?: (path: string) => Promise<string>,
+  ): Promise<PackageLayer[]> {
+    const packages: PackageLayer[] = [];
+
+    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) as string[];
+
+    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: PackageManifest | null = 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,
+      ) as PackageLayer['packageData']['packageManager'];
+
+      // 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: 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: PackageLayer['configFiles'] | undefined;
+      if (parser.detectConfigs) {
+        configFiles = parser.detectConfigs(packageData.path, fileTree, content);
+      }
+
+      // Detect documentation folder if the parser supports it
+      let docsFolder: string | undefined;
+      if (parser.detectDocsFolder) {
+        docsFolder = parser.detectDocsFolder(packageData.path, fileTree, content);
+      }
+
+      // Create package layer
+      const layer: PackageLayer = {
+        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,
+        pillar: 'foundationHealth',
+      };
+
+      packages.push(layer);
+    }
+
+    // Determine workspace relationships
+    this.resolveWorkspaceRelationships(packages);
+
+    return packages;
+  }
+
+  /**
+   * Create package layers from workspace boundaries (backwards compatibility)
+   */
+  createPackageLayersFromBoundaries(boundaries: WorkspaceBoundary[]): PackageLayer[] {
+    return boundaries.map(boundary => {
+      const fileSet: 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: PackageLayer['packageData'] = {
+        name: boundary.packageData?.name || boundary.name,
+        version: boundary.packageData?.version,
+        path: boundary.rootPath || '.',
+        packageManager: 'unknown',
+        dependencies: {},
+        devDependencies: {},
+        peerDependencies: {},
+        isMonorepoRoot: !!boundary.packageData?.workspaces,
+        isWorkspace: !boundary.isRoot && boundaries.length > 1,
+        parentPackage: boundary.isRoot ? undefined : 'root',
+      };
+
+      const layer: PackageLayer = {
+        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;
+    });
+  }
+
+  private isLockFile(path: string): boolean {
+    const lockFiles = [
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml',
+      'poetry.lock',
+      'Pipfile.lock',
+      'Cargo.lock',
+    ];
+
+    return lockFiles.some(lock => path.endsWith(lock));
+  }
+
+  private resolveWorkspaceRelationships(packages: PackageLayer[]): void {
+    // 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
+   */
+  private createMinimalManifest(packageType: string, packageName: string): PackageManifest {
+    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 {};
+    }
+  }
+}