@lousy-agents/cli 2.3.4 → 2.5.0

package/dist/index.js

@@ -10032,7 +10032,7 @@ function resolveArgs(argsDef) {
 function defineCommand(def) {
 	return def;
 }
-async function runCommand(cmd, opts) {
+async function dist_runCommand(cmd, opts) {
 	const cmdArgs = await resolveValue(cmd.args || {});
 	const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
 	const context = {
@@ -10051,7 +10051,7 @@ async function runCommand(cmd, opts) {
 			if (subCommandName) {
 				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
 				const subCommand = await resolveValue(subCommands[subCommandName]);
-				if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+				if (subCommand) await dist_runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
 			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
 		}
 		if (typeof cmd.run === "function") result = await cmd.run(context);
@@ -10151,7 +10151,7 @@ async function runMain(cmd, opts = {}) {
 			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
 			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
 			console.log(meta.version);
-		} else await runCommand(cmd, { rawArgs });
+		} else await dist_runCommand(cmd, { rawArgs });
 	} catch (error) {
 		if (error instanceof CLIError) {
 			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
@@ -11754,7 +11754,7 @@ const consola = dist_createConsola();
  */ 
 /**
  * Checks if a file or directory exists
- */ async function fileExists(path) {
+ */ async function file_system_utils_fileExists(path) {
     try {
         await (0,promises_.access)(path);
         return true;
@@ -11778,7 +11778,7 @@ const consola = dist_createConsola();
     }
     async agentFileExists(targetDir, agentName) {
         const filePath = this.getAgentFilePath(targetDir, agentName);
-        return fileExists(filePath);
+        return file_system_utils_fileExists(filePath);
     }
     async ensureAgentsDirectory(targetDir) {
         const agentsDir = (0,external_node_path_.join)(targetDir, ".github", "agents");
@@ -11799,6 +11799,27 @@ const consola = dist_createConsola();
     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
@@ -14086,12 +14107,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
@@ -14150,6 +14261,7 @@ async function watchConfig(options) {
 
 
 
+
 /**
  * Reads the content of a version file and trims whitespace
  */ async function readVersionFileContent(filePath) {
@@ -14167,14 +14279,26 @@ async function watchConfig(options) {
         return this.config;
     }
     async detectEnvironment(targetDir) {
-        const miseTomlPath = (0,external_node_path_.join)(targetDir, "mise.toml");
-        const hasMise = await 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){
             const filePath = (0,external_node_path_.join)(targetDir, fileConfig.filename);
-            if (await fileExists(filePath)) {
+            if (await file_system_utils_fileExists(filePath)) {
                 const version = await readVersionFileContent(filePath);
                 versionFiles.push({
                     type: filenameToType[fileConfig.filename],
@@ -14183,10 +14307,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;
     }
 }
 /**
@@ -14195,6 +14418,174 @@ async function watchConfig(options) {
     return new FileSystemEnvironmentGateway();
 }
 
+;// CONCATENATED MODULE: ./src/gateways/instruction-analysis-gateway.ts
+/**
+ * Gateway for analyzing repository instructions for feedback loop coverage
+ */ 
+
+
+/**
+ * File system implementation of instruction analysis gateway
+ */ class FileSystemInstructionAnalysisGateway {
+    async analyzeCoverage(targetDir, scripts, tools) {
+        // Find all instruction files
+        const instructionFiles = await this.findInstructionFiles(targetDir);
+        // Read and search instruction content
+        const references = [];
+        const documentedTargets = new Set();
+        for (const file of instructionFiles){
+            const content = await readFile(file, "utf-8");
+            const lines = content.split("\n");
+            // Check for script references (e.g., "npm test", "npm run build")
+            for (const script of scripts){
+                const scriptRefs = this.findReferencesInContent(script.name, content, lines, file, targetDir);
+                if (scriptRefs.length > 0) {
+                    references.push(...scriptRefs);
+                    documentedTargets.add(script.name);
+                }
+            }
+            // Check for tool references (e.g., "mise run test", "biome check")
+            for (const tool of tools){
+                const toolRefs = this.findReferencesInContent(tool.name, content, lines, file, targetDir);
+                if (toolRefs.length > 0) {
+                    references.push(...toolRefs);
+                    documentedTargets.add(tool.name);
+                }
+            }
+        }
+        // Filter mandatory scripts/tools
+        const mandatoryScripts = scripts.filter((s)=>s.isMandatory);
+        const mandatoryTools = tools.filter((t)=>t.isMandatory);
+        const allMandatory = [
+            ...mandatoryScripts,
+            ...mandatoryTools
+        ];
+        // Categorize as missing or documented
+        const missingInInstructions = allMandatory.filter((item)=>!documentedTargets.has(item.name));
+        const documentedInInstructions = allMandatory.filter((item)=>documentedTargets.has(item.name));
+        const totalMandatory = allMandatory.length;
+        const totalDocumented = documentedInInstructions.length;
+        const coveragePercentage = totalMandatory === 0 ? 100 : totalDocumented / totalMandatory * 100;
+        return {
+            missingInInstructions,
+            documentedInInstructions,
+            references,
+            summary: {
+                totalMandatory,
+                totalDocumented,
+                coveragePercentage: Math.round(coveragePercentage * 100) / 100
+            }
+        };
+    }
+    async findInstructionFiles(targetDir) {
+        const files = [];
+        // Check for .github/copilot-instructions.md
+        const copilotInstructions = join(targetDir, ".github", "copilot-instructions.md");
+        if (await fileExists(copilotInstructions)) {
+            files.push(copilotInstructions);
+        }
+        // Check for .github/instructions/*.md
+        const instructionsDir = join(targetDir, ".github", "instructions");
+        if (await fileExists(instructionsDir)) {
+            try {
+                const instructionFiles = await readdir(instructionsDir);
+                for (const file of instructionFiles){
+                    if (file.endsWith(".md")) {
+                        files.push(join(instructionsDir, file));
+                    }
+                }
+            } catch  {
+            // Skip directory if we can't read it (e.g., permissions issues)
+            // Similar to how workflow parsing errors are handled
+            }
+        }
+        return files;
+    }
+    findReferencesInContent(target, content, lines, file, targetDir) {
+        const references = [];
+        // Build a case-insensitive, word-boundary-aware pattern for the target.
+        // This reduces false positives from simple substring matches like
+        // "test" in "testing" or "latest", while still matching common
+        // separators such as spaces, punctuation, etc.
+        const escapedTarget = target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const targetPattern = new RegExp(`(?:^|[^\\w])(${escapedTarget})(?=$|[^\\w])`, "i");
+        // Fast path: skip line-by-line processing if the target pattern
+        // never appears in the full content.
+        if (!targetPattern.test(content)) {
+            return references;
+        }
+        // Find line numbers where target appears
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i];
+            if (targetPattern.test(line)) {
+                // Get context (line before and after if available)
+                const contextLines = [];
+                if (i > 0) contextLines.push(lines[i - 1]);
+                contextLines.push(line);
+                if (i < lines.length - 1) contextLines.push(lines[i + 1]);
+                const relativePath = relative(targetDir, file);
+                references.push({
+                    target,
+                    file: relativePath,
+                    line: i + 1,
+                    context: contextLines.join("\n")
+                });
+            }
+        }
+        return references;
+    }
+}
+/**
+ * Creates and returns the default instruction analysis gateway
+ */ function createInstructionAnalysisGateway() {
+    return new FileSystemInstructionAnalysisGateway();
+}
+
+;// CONCATENATED MODULE: ./src/gateways/script-discovery-gateway.ts
+/**
+ * Gateway for discovering scripts from package.json manifests
+ */ 
+
+
+
+/**
+ * File system implementation of script discovery gateway
+ */ class FileSystemScriptDiscoveryGateway {
+    async discoverScripts(targetDir) {
+        const packageJsonPath = join(targetDir, "package.json");
+        if (!await fileExists(packageJsonPath)) {
+            return [];
+        }
+        try {
+            const content = await readFile(packageJsonPath, "utf-8");
+            const packageJson = JSON.parse(content);
+            if (!packageJson.scripts) {
+                return [];
+            }
+            const scripts = [];
+            for (const [name, command] of Object.entries(packageJson.scripts)){
+                const phase = determineScriptPhase(name, command);
+                const isMandatory = isScriptMandatory(phase);
+                scripts.push({
+                    name,
+                    command,
+                    phase,
+                    isMandatory
+                });
+            }
+            return scripts;
+        } catch  {
+            // If package.json is malformed or cannot be parsed, return empty array
+            return [];
+        }
+    }
+}
+/**
+ * Creates and returns the default script discovery gateway
+ */ function createScriptDiscoveryGateway() {
+    return new FileSystemScriptDiscoveryGateway();
+}
+
 ;// CONCATENATED MODULE: ./src/gateways/skill-file-gateway.ts
 /**
  * Gateway for skill file system operations.
@@ -14213,7 +14604,7 @@ async function watchConfig(options) {
     }
     async skillDirectoryExists(targetDir, skillName) {
         const dirPath = this.getSkillDirectoryPath(targetDir, skillName);
-        return fileExists(dirPath);
+        return file_system_utils_fileExists(dirPath);
     }
     async ensureSkillDirectory(targetDir, skillName) {
         const skillDir = this.getSkillDirectoryPath(targetDir, skillName);
@@ -14236,6 +14627,160 @@ async function watchConfig(options) {
 
 // EXTERNAL MODULE: ./node_modules/yaml/dist/index.js
 var dist = __webpack_require__(1198);
+;// CONCATENATED MODULE: ./src/gateways/tool-discovery-gateway.ts
+/**
+ * Gateway for discovering CLI tools and commands from GitHub Actions workflows
+ */ 
+
+
+
+
+/**
+ * File system implementation of tool discovery gateway
+ */ class FileSystemToolDiscoveryGateway {
+    async discoverTools(targetDir) {
+        const workflowsDir = join(targetDir, ".github", "workflows");
+        if (!await fileExists(workflowsDir)) {
+            return [];
+        }
+        const files = await readdir(workflowsDir);
+        const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
+        const allTools = [];
+        for (const file of yamlFiles){
+            const filePath = join(workflowsDir, file);
+            try {
+                const content = await readFile(filePath, "utf-8");
+                const workflow = parseYaml(content);
+                const tools = this.extractToolsFromWorkflow(workflow, file);
+                allTools.push(...tools);
+            } catch  {
+            // Skip files that can't be parsed as valid YAML
+            }
+        }
+        return this.deduplicateTools(allTools);
+    }
+    extractToolsFromWorkflow(workflow, sourceFile) {
+        const tools = [];
+        if (!workflow || typeof workflow !== "object") {
+            return tools;
+        }
+        const jobs = workflow.jobs;
+        if (!jobs || typeof jobs !== "object") {
+            return tools;
+        }
+        for (const job of Object.values(jobs)){
+            if (!job || typeof job !== "object") {
+                continue;
+            }
+            const steps = job.steps;
+            if (!Array.isArray(steps)) {
+                continue;
+            }
+            for (const step of steps){
+                if (!step || typeof step !== "object") {
+                    continue;
+                }
+                const stepObj = step;
+                const run = stepObj.run;
+                if (typeof run === "string") {
+                    // Extract tools from run commands
+                    const extractedTools = this.extractToolsFromRunCommand(run, sourceFile);
+                    tools.push(...extractedTools);
+                }
+            }
+        }
+        return tools;
+    }
+    extractToolsFromRunCommand(runCommand, sourceFile) {
+        const tools = [];
+        // Split by newlines and pipe tokens with surrounding whitespace to handle
+        // multi-line and piped commands without breaking on constructs like "cmd || true"
+        const commands = runCommand.split(/\n|\s\|\s/).map((c)=>c.trim()).filter((c)=>c.length > 0 && !c.startsWith("#"));
+        for (const command of commands){
+            // Extract the base command (first word)
+            const parts = command.split(/\s+/);
+            const baseCommand = parts[0];
+            // Skip shell built-ins and common utilities
+            if (this.isShellBuiltin(baseCommand)) {
+                continue;
+            }
+            // Determine tool name and full command
+            let toolName;
+            const fullCommand = command;
+            // Handle special cases like "npm run", "mise run", etc.
+            if (parts.length >= 2 && (baseCommand === "npm" || baseCommand === "mise") && parts[1] === "run") {
+                if (parts.length >= 3 && parts[2]) {
+                    // "npm run test" -> name: "npm run test"
+                    toolName = parts.slice(0, 3).join(" ");
+                } else {
+                    // Handle commands like "npm run" without a script name
+                    toolName = parts.slice(0, 2).join(" ");
+                }
+            } else if (parts.length >= 2) {
+                // For most tools, include the subcommand for better specificity
+                // e.g., "npm test", "npx biome", "pnpm lint"
+                toolName = parts.slice(0, 2).join(" ");
+            } else {
+                // Fallback to the base command if no subcommand is present
+                toolName = baseCommand;
+            }
+            const phase = this.determineToolPhase(toolName, fullCommand);
+            const isMandatory = isScriptMandatory(phase);
+            tools.push({
+                name: toolName,
+                fullCommand,
+                phase,
+                isMandatory,
+                sourceWorkflow: sourceFile
+            });
+        }
+        return tools;
+    }
+    isShellBuiltin(command) {
+        const builtins = [
+            "cd",
+            "echo",
+            "mkdir",
+            "rm",
+            "cp",
+            "mv",
+            "test",
+            "[",
+            "if",
+            "then",
+            "else",
+            "fi",
+            "for",
+            "while",
+            "do",
+            "done",
+            "case",
+            "esac"
+        ];
+        return builtins.includes(command);
+    }
+    determineToolPhase(toolName, fullCommand) {
+        // Use the same logic as script phase determination
+        return determineScriptPhase(toolName, fullCommand);
+    }
+    deduplicateTools(tools) {
+        const seen = new Map();
+        for (const tool of tools){
+            // Use full command as key for deduplication
+            const key = tool.fullCommand;
+            if (!seen.has(key)) {
+                seen.set(key, tool);
+            }
+        }
+        return Array.from(seen.values());
+    }
+}
+/**
+ * Creates and returns the default tool discovery gateway
+ */ function createToolDiscoveryGateway() {
+    return new FileSystemToolDiscoveryGateway();
+}
+
 ;// CONCATENATED MODULE: ./src/use-cases/setup-step-discovery.ts
 /**
  * Use case for discovering setup steps in workflows.
@@ -14459,7 +15004,7 @@ var dist = __webpack_require__(1198);
         const workflowsDir = (0,external_node_path_.join)(targetDir, ".github", "workflows");
         for (const filename of COPILOT_SETUP_WORKFLOW_FILENAMES){
             const workflowPath = (0,external_node_path_.join)(workflowsDir, filename);
-            if (await fileExists(workflowPath)) {
+            if (await file_system_utils_fileExists(workflowPath)) {
                 return workflowPath;
             }
         }
@@ -14467,7 +15012,7 @@ var dist = __webpack_require__(1198);
     }
     async parseWorkflowsForSetupActions(targetDir) {
         const workflowsDir = (0,external_node_path_.join)(targetDir, ".github", "workflows");
-        if (!await fileExists(workflowsDir)) {
+        if (!await file_system_utils_fileExists(workflowsDir)) {
             return [];
         }
         const files = await (0,promises_.readdir)(workflowsDir);
@@ -14534,11 +15079,14 @@ var dist = __webpack_require__(1198);
 
 
 
+
+
+
 ;// CONCATENATED MODULE: ./src/use-cases/candidate-builder.ts
 /**
  * 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.
  */ 
 
 /**
@@ -14563,7 +15111,12 @@ var dist = __webpack_require__(1198);
         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
@@ -14598,6 +15151,59 @@ var dist = __webpack_require__(1198);
     }
     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
 /**
@@ -15146,11 +15752,22 @@ Example resolved format: actions/setup-node@1a2b3c4d5e6f  # v4.0.0`;
  * @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
     };
@@ -15327,7 +15944,7 @@ const copilotSetupArgs = {};
         }
         // Step 2: Parse existing workflows for setup actions
         const workflowsDir = (0,external_node_path_.join)(targetDir, ".github", "workflows");
-        const workflowsDirExists = await fileExists(workflowsDir);
+        const workflowsDirExists = await file_system_utils_fileExists(workflowsDir);
         const workflowCandidates = workflowsDirExists ? await workflowGateway.parseWorkflowsForSetupActions(targetDir) : [];
         if (workflowCandidates.length > 0) {
             const actionNames = workflowCandidates.map((c)=>c.action).join(", ");
@@ -30219,7 +30836,7 @@ var Eta = class extends Eta$1 {
     for (const node of structure.nodes){
         const fullPath = (0,external_node_path_.join)(targetDir, node.path);
         // Skip if already exists to preserve existing files/directories
-        if (await fileExists(fullPath)) {
+        if (await file_system_utils_fileExists(fullPath)) {
             consola.debug(`Skipping existing: ${fullPath}`);
             continue;
         }