@lousy-agents/cli 2.3.3 → 2.4.0

package/dist/mcp-server.js

@@ -42578,6 +42578,27 @@ var yaml_dist = __webpack_require__(1198);
     return new FileSystemAgentFileGateway();
 }
 
+;// CONCATENATED MODULE: ./src/entities/copilot-setup.ts
+/**
+ * Core domain entities for the Copilot Setup Steps feature.
+ * These are the fundamental types that represent the business domain.
+ */ /**
+ * Types of version files supported for detection
+ */ /**
+ * Node.js package manager types (in priority order: npm > yarn > pnpm)
+ */ const NODE_PACKAGE_MANAGERS = [
+    "npm",
+    "yarn",
+    "pnpm"
+];
+/**
+ * Python package manager types (in priority order)
+ */ const PYTHON_PACKAGE_MANAGERS = [
+    "poetry",
+    "pipenv",
+    "pip"
+];
+
 // EXTERNAL MODULE: external "node:fs"
 var external_node_fs_ = __webpack_require__(3024);
 // EXTERNAL MODULE: ./node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -44867,12 +44888,102 @@ async function watchConfig(options) {
     "actions/setup-ruby",
     "jdx/mise-action"
 ];
+/**
+ * Default package manager mappings
+ * Based on Dependabot supported ecosystems
+ */ const DEFAULT_PACKAGE_MANAGERS = [
+    // Node.js package managers
+    {
+        type: "npm",
+        manifestFile: "package.json",
+        lockfile: "package-lock.json",
+        installCommand: "npm ci"
+    },
+    {
+        type: "yarn",
+        manifestFile: "package.json",
+        lockfile: "yarn.lock",
+        installCommand: "yarn install --frozen-lockfile"
+    },
+    {
+        type: "pnpm",
+        manifestFile: "package.json",
+        lockfile: "pnpm-lock.yaml",
+        installCommand: "pnpm install --frozen-lockfile"
+    },
+    // Python package managers
+    {
+        type: "pip",
+        manifestFile: "requirements.txt",
+        installCommand: "pip install -r requirements.txt"
+    },
+    {
+        type: "pipenv",
+        manifestFile: "Pipfile",
+        lockfile: "Pipfile.lock",
+        installCommand: "pipenv install --deploy"
+    },
+    {
+        type: "poetry",
+        manifestFile: "pyproject.toml",
+        lockfile: "poetry.lock",
+        requiresLockfile: true,
+        installCommand: "poetry install --no-root"
+    },
+    // Ruby
+    {
+        type: "bundler",
+        manifestFile: "Gemfile",
+        lockfile: "Gemfile.lock",
+        installCommand: "bundle install"
+    },
+    // Rust
+    {
+        type: "cargo",
+        manifestFile: "Cargo.toml",
+        lockfile: "Cargo.lock",
+        installCommand: "cargo build"
+    },
+    // PHP
+    {
+        type: "composer",
+        manifestFile: "composer.json",
+        lockfile: "composer.lock",
+        installCommand: "composer install"
+    },
+    // Java
+    {
+        type: "maven",
+        manifestFile: "pom.xml",
+        installCommand: "mvn install -DskipTests"
+    },
+    {
+        type: "gradle",
+        manifestFile: "build.gradle",
+        installCommand: "gradle build -x test"
+    },
+    // Go
+    {
+        type: "gomod",
+        manifestFile: "go.mod",
+        lockfile: "go.sum",
+        installCommand: "go mod download"
+    },
+    // Dart/Flutter
+    {
+        type: "pub",
+        manifestFile: "pubspec.yaml",
+        lockfile: "pubspec.lock",
+        installCommand: "dart pub get"
+    }
+];
 /**
  * Default copilot-setup configuration
  */ const DEFAULT_CONFIG = {
     versionFiles: DEFAULT_VERSION_FILES,
     setupActions: DEFAULT_SETUP_ACTIONS,
-    setupActionPatterns: DEFAULT_SETUP_ACTION_PATTERNS
+    setupActionPatterns: DEFAULT_SETUP_ACTION_PATTERNS,
+    packageManagers: DEFAULT_PACKAGE_MANAGERS
 };
 /**
  * Loads the copilot-setup configuration using c12
@@ -44931,6 +45042,7 @@ async function watchConfig(options) {
 
 
 
+
 /**
  * Reads the content of a version file and trims whitespace
  */ async function readVersionFileContent(filePath) {
@@ -44948,9 +45060,21 @@ async function watchConfig(options) {
         return this.config;
     }
     async detectEnvironment(targetDir) {
-        const miseTomlPath = (0,external_node_path_.join)(targetDir, "mise.toml");
-        const hasMise = await file_system_utils_fileExists(miseTomlPath);
         const config = await this.getConfig();
+        const hasMise = await this.detectMise(targetDir);
+        const versionFiles = await this.detectVersionFiles(targetDir, config);
+        const packageManagers = await this.detectPackageManagers(targetDir, config);
+        return {
+            hasMise,
+            versionFiles,
+            packageManagers
+        };
+    }
+    async detectMise(targetDir) {
+        const miseTomlPath = (0,external_node_path_.join)(targetDir, "mise.toml");
+        return file_system_utils_fileExists(miseTomlPath);
+    }
+    async detectVersionFiles(targetDir, config) {
         const filenameToType = getVersionFilenameToTypeMap(config);
         const versionFiles = [];
         for (const fileConfig of config.versionFiles){
@@ -44964,10 +45088,109 @@ async function watchConfig(options) {
                 });
             }
         }
-        return {
-            hasMise,
-            versionFiles
-        };
+        return versionFiles;
+    }
+    async detectPackageManagers(targetDir, config) {
+        const packageManagers = [];
+        // Helper to check if a package manager type is in a list
+        const isPackageManagerType = (pm, types)=>types.includes(pm.type);
+        const nodePackageManagers = config.packageManagers.filter((pm)=>isPackageManagerType(pm, NODE_PACKAGE_MANAGERS));
+        const pythonPackageManagers = config.packageManagers.filter((pm)=>isPackageManagerType(pm, PYTHON_PACKAGE_MANAGERS));
+        const otherPackageManagers = config.packageManagers.filter((pm)=>!isPackageManagerType(pm, NODE_PACKAGE_MANAGERS) && !isPackageManagerType(pm, PYTHON_PACKAGE_MANAGERS));
+        // Detect Node.js package manager (with prioritization)
+        const nodePackageManager = await this.detectNodePackageManager(targetDir, nodePackageManagers);
+        if (nodePackageManager) {
+            packageManagers.push(nodePackageManager);
+        }
+        // Detect Python package manager (with prioritization)
+        const pythonPackageManager = await this.detectPythonPackageManager(targetDir, pythonPackageManagers);
+        if (pythonPackageManager) {
+            packageManagers.push(pythonPackageManager);
+        }
+        // Detect other package managers
+        const otherDetectedManagers = await this.detectOtherPackageManagers(targetDir, otherPackageManagers);
+        packageManagers.push(...otherDetectedManagers);
+        return packageManagers;
+    }
+    async detectNodePackageManager(targetDir, nodePackageManagers) {
+        const packageJsonPath = (0,external_node_path_.join)(targetDir, "package.json");
+        if (!await file_system_utils_fileExists(packageJsonPath)) {
+            return null;
+        }
+        // Priority order for Node.js package managers: npm > yarn > pnpm
+        const lockfileOrder = [
+            "npm",
+            "yarn",
+            "pnpm"
+        ];
+        for (const pmType of lockfileOrder){
+            const pmConfig = nodePackageManagers.find((pm)=>pm.type === pmType);
+            if (!pmConfig?.lockfile) {
+                continue;
+            }
+            const lockfilePath = (0,external_node_path_.join)(targetDir, pmConfig.lockfile);
+            if (await file_system_utils_fileExists(lockfilePath)) {
+                return {
+                    type: pmConfig.type,
+                    filename: pmConfig.manifestFile,
+                    lockfile: pmConfig.lockfile
+                };
+            }
+        }
+        // Default to npm if no lockfile found
+        const npmConfig = nodePackageManagers.find((pm)=>pm.type === "npm");
+        if (npmConfig) {
+            return {
+                type: npmConfig.type,
+                filename: npmConfig.manifestFile,
+                lockfile: undefined
+            };
+        }
+        return null;
+    }
+    async detectPythonPackageManager(targetDir, pythonPackageManagers) {
+        // Priority order for Python package managers: poetry > pipenv > pip
+        for (const pmType of PYTHON_PACKAGE_MANAGERS){
+            const pmConfig = pythonPackageManagers.find((pm)=>pm.type === pmType);
+            if (!pmConfig) {
+                continue;
+            }
+            const manifestPath = (0,external_node_path_.join)(targetDir, pmConfig.manifestFile);
+            if (await file_system_utils_fileExists(manifestPath)) {
+                const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
+                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
+                // Skip if lockfile is required but not present
+                if (pmConfig.requiresLockfile && !hasLockfile) {
+                    continue;
+                }
+                return {
+                    type: pmConfig.type,
+                    filename: pmConfig.manifestFile,
+                    lockfile: hasLockfile ? pmConfig.lockfile : undefined
+                };
+            }
+        }
+        return null;
+    }
+    async detectOtherPackageManagers(targetDir, otherPackageManagers) {
+        const packageManagers = [];
+        for (const pmConfig of otherPackageManagers){
+            const manifestPath = (0,external_node_path_.join)(targetDir, pmConfig.manifestFile);
+            if (await file_system_utils_fileExists(manifestPath)) {
+                const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
+                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
+                // Skip if lockfile is required but not present
+                if (pmConfig.requiresLockfile && !hasLockfile) {
+                    continue;
+                }
+                packageManagers.push({
+                    type: pmConfig.type,
+                    filename: pmConfig.manifestFile,
+                    lockfile: hasLockfile ? pmConfig.lockfile : undefined
+                });
+            }
+        }
+        return packageManagers;
     }
 }
 /**
@@ -45532,7 +45755,7 @@ Example resolved format: actions/setup-node@1a2b3c4d5e6f  # v4.0.0`;
 /**
  * Use case for building setup step candidates from environment detection.
  * This module handles the logic of determining which GitHub Actions
- * setup steps should be added based on detected version files.
+ * setup steps should be added based on detected version files and package managers.
  */ 
 
 /**
@@ -45557,7 +45780,12 @@ Example resolved format: actions/setup-node@1a2b3c4d5e6f  # v4.0.0`;
         return candidates;
     }
     // Otherwise, add individual setup actions for each version file
-    return buildCandidatesFromVersionFiles(environment.versionFiles, versionTypeToAction, versionFileConfigKeys, versionGateway);
+    const setupCandidates = await buildCandidatesFromVersionFiles(environment.versionFiles, versionTypeToAction, versionFileConfigKeys, versionGateway);
+    candidates.push(...setupCandidates);
+    // Add install steps for detected package managers
+    const installCandidates = buildInstallCandidatesFromPackageManagers(environment.packageManagers, loadedConfig);
+    candidates.push(...installCandidates);
+    return candidates;
 }
 /**
  * Builds setup step candidates from individual version files
@@ -45592,6 +45820,59 @@ Example resolved format: actions/setup-node@1a2b3c4d5e6f  # v4.0.0`;
     }
     return candidates;
 }
+/**
+ * Builds install step candidates from detected package managers
+ * @param packageManagers Array of detected package managers
+ * @param config Configuration for package manager mappings
+ * @returns Array of install step candidates
+ */ function buildInstallCandidatesFromPackageManagers(packageManagers, config) {
+    const candidates = [];
+    const addedTypes = new Set();
+    for (const pm of packageManagers){
+        // Skip if we've already added this package manager type
+        if (addedTypes.has(pm.type)) {
+            continue;
+        }
+        addedTypes.add(pm.type);
+        // Find the config for this package manager
+        const pmConfig = config.packageManagers.find((c)=>c.type === pm.type);
+        if (!pmConfig) {
+            continue;
+        }
+        // Determine a descriptive name for the install step
+        const stepName = getInstallStepName(pm.type);
+        // Create install step candidate
+        // Note: Empty action string indicates this is a run step (uses 'run' field instead of 'uses')
+        // This is checked in workflow-generator.ts buildStepFromCandidate()
+        candidates.push({
+            action: "",
+            source: "version-file",
+            name: stepName,
+            run: pmConfig.installCommand
+        });
+    }
+    return candidates;
+}
+/**
+ * Gets a descriptive name for an install step based on package manager type
+ */ function getInstallStepName(packageManagerType) {
+    const names = {
+        npm: "Install Node.js dependencies",
+        yarn: "Install Node.js dependencies",
+        pnpm: "Install Node.js dependencies",
+        pip: "Install Python dependencies",
+        pipenv: "Install Python dependencies",
+        poetry: "Install Python dependencies",
+        bundler: "Install Ruby dependencies",
+        cargo: "Build Rust project",
+        composer: "Install PHP dependencies",
+        maven: "Install Java dependencies",
+        gradle: "Build Gradle project",
+        gomod: "Download Go dependencies",
+        pub: "Install Dart dependencies"
+    };
+    return names[packageManagerType] || "Install dependencies";
+}
 
 ;// CONCATENATED MODULE: ./node_modules/@github-actions-workflow-ts/lib/dist/esm/workflow/index.js
 /**
@@ -46037,11 +46318,22 @@ function getGlobalWacContext() {
  * @param options Optional conversion options for placeholders and resolved versions
  * @returns A typed Step object
  */ function buildStepFromCandidate(candidate, options) {
+    // Handle run steps (install commands)
+    // Run steps have a 'run' field and no action (or empty action string)
+    if (candidate.run && !candidate.action) {
+        const stepProps = {
+            name: candidate.name || "Run command",
+            run: candidate.run
+        };
+        // Type assertion is safe here - Step constructor accepts both 'uses' and 'run' at runtime
+        return new Step(stepProps);
+    }
+    // Handle action steps (uses)
     const version = getVersionForAction(candidate.action, candidate.version, options);
     const usesValue = buildUsesValue(candidate.action, version, options);
     const withConfig = candidate.config && Object.keys(candidate.config).length > 0 ? candidate.config : undefined;
     const stepProps = {
-        name: generateStepName(candidate.action),
+        name: candidate.name || generateStepName(candidate.action),
         uses: usesValue,
         with: withConfig
     };