@lousy-agents/cli 2.3.3 → 2.4.0

package/dist/index.js

@@ -9798,7 +9798,6 @@ __webpack_require__.d(classic_schemas_namespaceObject, {
 
 
 ;// CONCATENATED MODULE: ./node_modules/citty/dist/_chunks/libs/scule.mjs
-//#region node_modules/.pnpm/scule@1.3.0/node_modules/scule/dist/index.mjs
 const NUMBER_CHAR_RE = /\d/;
 const STR_SPLITTERS = [
 	"-",
@@ -9864,15 +9863,12 @@ function kebabCase(str, joiner) {
 	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
 
-//#endregion
 
 // EXTERNAL MODULE: external "node:util"
 var external_node_util_ = __webpack_require__(7975);
 ;// CONCATENATED MODULE: ./node_modules/citty/dist/index.mjs
 
 
-
-//#region src/_utils.ts
 function toArray(val) {
 	if (Array.isArray(val)) return val;
 	return val === void 0 ? [] : [val];
@@ -9893,9 +9889,6 @@ var CLIError = class extends Error {
 		this.code = code;
 	}
 };
-
-//#endregion
-//#region src/_parser.ts
 function parseRawArgs(args = [], opts = {}) {
 	const booleans = new Set(opts.boolean || []);
 	const strings = new Set(opts.string || []);
@@ -9965,16 +9958,19 @@ function parseRawArgs(args = [], opts = {}) {
 	const out = { _: [] };
 	out._ = parsed.positionals;
 	for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
-	for (const [name] of Object.entries(negatedFlags)) out[name] = false;
+	for (const [name] of Object.entries(negatedFlags)) {
+		out[name] = false;
+		const mainName = aliasToMain.get(name);
+		if (mainName) out[mainName] = false;
+		const aliases = mainToAliases.get(name);
+		if (aliases) for (const alias of aliases) out[alias] = false;
+	}
 	for (const [alias, main] of aliasToMain.entries()) {
 		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
 		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
 	}
 	return out;
 }
-
-//#endregion
-//#region src/_color.ts
 const noColor = /* @__PURE__ */ (() => {
 	const env = globalThis.process?.env ?? {};
 	return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
@@ -9984,9 +9980,6 @@ const bold = /* @__PURE__ */ _c(1, 22);
 const cyan = /* @__PURE__ */ _c(36);
 const gray = /* @__PURE__ */ _c(90);
 const underline = /* @__PURE__ */ _c(4, 24);
-
-//#endregion
-//#region src/args.ts
 function parseArgs(rawArgs, argsDef) {
 	const parseOptions = {
 		boolean: [],
@@ -10036,9 +10029,6 @@ function resolveArgs(argsDef) {
 	});
 	return args;
 }
-
-//#endregion
-//#region src/command.ts
 function defineCommand(def) {
 	return def;
 }
@@ -10080,9 +10070,6 @@ async function resolveSubCommand(cmd, rawArgs, parent) {
 	}
 	return [cmd, parent];
 }
-
-//#endregion
-//#region src/usage.ts
 async function showUsage(cmd, parent) {
 	try {
 		console.log(await renderUsage(cmd, parent) + "\n");
@@ -10114,11 +10101,6 @@ async function renderUsage(cmd, parent) {
 		const isRequired = arg.required === true && arg.default === void 0;
 		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
 		argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
-		/**
-		* print negative boolean arg variant usage when
-		* - enabled by default or has `negativeDescription`
-		* - not prefixed with `no-` or `no[A-Z]`
-		*/
 		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
 			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
 			argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
@@ -10158,9 +10140,6 @@ async function renderUsage(cmd, parent) {
 	}
 	return usageLines.filter((l) => typeof l === "string").join("\n");
 }
-
-//#endregion
-//#region src/main.ts
 async function runMain(cmd, opts = {}) {
 	const rawArgs = opts.rawArgs || process.argv.slice(2);
 	const showUsage$1 = opts.showUsage || showUsage;
@@ -10185,7 +10164,6 @@ function createMain(cmd) {
 	return (opts = {}) => runMain(cmd, opts);
 }
 
-//#endregion
 
 // EXTERNAL MODULE: external "node:fs/promises"
 var promises_ = __webpack_require__(1455);
@@ -11821,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
@@ -14108,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
@@ -14172,6 +14261,7 @@ async function watchConfig(options) {
 
 
 
+
 /**
  * Reads the content of a version file and trims whitespace
  */ async function readVersionFileContent(filePath) {
@@ -14189,9 +14279,21 @@ 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 fileExists(miseTomlPath);
+    }
+    async detectVersionFiles(targetDir, config) {
         const filenameToType = getVersionFilenameToTypeMap(config);
         const versionFiles = [];
         for (const fileConfig of config.versionFiles){
@@ -14205,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 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 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 fileExists(manifestPath)) {
+                const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
+                const hasLockfile = lockfilePath ? await 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 fileExists(manifestPath)) {
+                const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
+                const hasLockfile = lockfilePath ? await 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;
     }
 }
 /**
@@ -14560,7 +14761,7 @@ var dist = __webpack_require__(1198);
 /**
  * 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.
  */ 
 
 /**
@@ -14585,7 +14786,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
@@ -14620,6 +14826,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
 /**
@@ -15168,11 +15427,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
     };