@lousy-agents/cli 2.3.4 → 2.5.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;
     }
 }
 /**
@@ -44976,6 +45199,283 @@ 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 (0,promises_.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 = (0,external_node_path_.join)(targetDir, ".github", "copilot-instructions.md");
+        if (await file_system_utils_fileExists(copilotInstructions)) {
+            files.push(copilotInstructions);
+        }
+        // Check for .github/instructions/*.md
+        const instructionsDir = (0,external_node_path_.join)(targetDir, ".github", "instructions");
+        if (await file_system_utils_fileExists(instructionsDir)) {
+            try {
+                const instructionFiles = await (0,promises_.readdir)(instructionsDir);
+                for (const file of instructionFiles){
+                    if (file.endsWith(".md")) {
+                        files.push((0,external_node_path_.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 = (0,external_node_path_.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/entities/feedback-loop.ts
+/**
+ * Core domain entities for SDLC feedback loop discovery and validation.
+ * These types represent scripts, tools, and their mapping to SDLC phases.
+ */ /**
+ * SDLC feedback loop phases that scripts and tools support
+ */ /**
+ * Maps common script names to SDLC phases
+ */ const SCRIPT_PHASE_MAPPING = {
+    test: "test",
+    "test:unit": "test",
+    "test:integration": "test",
+    "test:e2e": "test",
+    "test:watch": "test",
+    build: "build",
+    compile: "build",
+    bundle: "build",
+    lint: "lint",
+    "lint:fix": "lint",
+    "lint:check": "lint",
+    "lint:workflows": "lint",
+    "lint:yaml": "lint",
+    format: "format",
+    "format:check": "format",
+    "format:fix": "format",
+    prettier: "format",
+    "prettier:check": "format",
+    "prettier:fix": "format",
+    audit: "security",
+    "audit:fix": "security",
+    security: "security",
+    deploy: "deploy",
+    publish: "deploy",
+    release: "deploy",
+    install: "install",
+    ci: "install",
+    dev: "dev",
+    start: "dev",
+    serve: "dev"
+};
+/**
+ * Scripts that are considered mandatory for agent feedback loops
+ */ const MANDATORY_SCRIPT_NAMES = (/* unused pure expression or super */ null && ([
+    "test",
+    "build",
+    "lint",
+    "format"
+]));
+/**
+ * Determines the SDLC phase for a script based on its name and command
+ */ function determineScriptPhase(scriptName, command) {
+    // Check exact name match first
+    const exactMatch = SCRIPT_PHASE_MAPPING[scriptName];
+    if (exactMatch) {
+        return exactMatch;
+    }
+    // Check if name starts with a known phase
+    for (const [pattern, phase] of Object.entries(SCRIPT_PHASE_MAPPING)){
+        // Skip patterns we've already handled as exact matches
+        if (pattern === scriptName) {
+            continue;
+        }
+        if (!scriptName.startsWith(pattern)) {
+            continue;
+        }
+        // If the pattern itself includes a separator (e.g. "test:unit"),
+        // allow simple prefix matching (handles "test:unit:watch", etc.)
+        const lastCharOfPattern = pattern.charAt(pattern.length - 1);
+        if (lastCharOfPattern === ":") {
+            return phase;
+        }
+        // For generic patterns like "test" or "build", require that the next
+        // character after the pattern is a colon to avoid matching names
+        // like "test-utils" or "build-tools".
+        const nextChar = scriptName.charAt(pattern.length);
+        if (nextChar === ":") {
+            return phase;
+        }
+    }
+    // Analyze command content for hints (not script name, since we already checked patterns)
+    const lowerCommand = command.toLowerCase();
+    if (lowerCommand.includes("test") || lowerCommand.includes("vitest") || lowerCommand.includes("jest") || lowerCommand.includes("mocha") || lowerCommand.includes("ava")) {
+        return "test";
+    }
+    if (lowerCommand.includes("build") || lowerCommand.includes("compile") || lowerCommand.includes("webpack") || lowerCommand.includes("rspack") || lowerCommand.includes("rollup") || lowerCommand.includes("vite build")) {
+        return "build";
+    }
+    if (lowerCommand.includes("lint") || lowerCommand.includes("eslint") || lowerCommand.includes("biome") || lowerCommand.includes("tslint") || lowerCommand.includes("actionlint") || lowerCommand.includes("yamllint")) {
+        return "lint";
+    }
+    if (lowerCommand.includes("prettier") || lowerCommand.includes("format")) {
+        return "format";
+    }
+    if (lowerCommand.includes("audit") || lowerCommand.includes("snyk") || lowerCommand.includes("npm-audit")) {
+        return "security";
+    }
+    return "unknown";
+}
+/**
+ * Determines if a script is mandatory based on its phase
+ */ function isScriptMandatory(phase) {
+    return [
+        "test",
+        "build",
+        "lint",
+        "format"
+    ].includes(phase);
+}
+
+;// 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 = (0,external_node_path_.join)(targetDir, "package.json");
+        if (!await file_system_utils_fileExists(packageJsonPath)) {
+            return [];
+        }
+        try {
+            const content = await (0,promises_.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.
@@ -45015,6 +45515,160 @@ async function watchConfig(options) {
     return new FileSystemSkillFileGateway();
 }
 
+;// 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 = (0,external_node_path_.join)(targetDir, ".github", "workflows");
+        if (!await file_system_utils_fileExists(workflowsDir)) {
+            return [];
+        }
+        const files = await (0,promises_.readdir)(workflowsDir);
+        const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
+        const allTools = [];
+        for (const file of yamlFiles){
+            const filePath = (0,external_node_path_.join)(workflowsDir, file);
+            try {
+                const content = await (0,promises_.readFile)(filePath, "utf-8");
+                const workflow = (0,yaml_dist.parse)(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.
@@ -45313,6 +45967,9 @@ async function watchConfig(options) {
 
 
 
+
+
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/types.ts
 /**
  * Shared types and utilities for MCP tool handlers.
@@ -45532,7 +46189,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 +46214,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 +46254,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 +46752,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
     };
@@ -46319,6 +47045,140 @@ function getGlobalWacContext() {
     });
 };
 
+;// CONCATENATED MODULE: ./src/use-cases/discover-feedback-loops.ts
+/**
+ * Use case for discovering and analyzing SDLC feedback loops
+ */ /**
+ * Use case for discovering scripts and tools that form SDLC feedback loops
+ */ class DiscoverFeedbackLoopsUseCase {
+    scriptGateway;
+    toolGateway;
+    packageManagerGateway;
+    constructor(scriptGateway, toolGateway, packageManagerGateway){
+        this.scriptGateway = scriptGateway;
+        this.toolGateway = toolGateway;
+        this.packageManagerGateway = packageManagerGateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        // Discover scripts from package.json
+        const scripts = await this.scriptGateway.discoverScripts(input.targetDir);
+        // Discover tools from GitHub Actions workflows
+        const tools = await this.toolGateway.discoverTools(input.targetDir);
+        // Detect package manager
+        const packageManagers = await this.packageManagerGateway.detectPackageManagers(input.targetDir);
+        const primaryPackageManager = packageManagers.length > 0 ? packageManagers[0].type : undefined;
+        const feedbackLoops = {
+            scripts: this.sortByPhase(scripts),
+            tools: this.sortByPhase(tools),
+            packageManager: primaryPackageManager
+        };
+        return {
+            feedbackLoops
+        };
+    }
+    /**
+     * Sorts scripts or tools by phase priority
+     * Order: test, lint, format, build, security, install, dev, deploy, unknown
+     */ sortByPhase(items) {
+        const phasePriority = {
+            test: 1,
+            lint: 2,
+            format: 3,
+            build: 4,
+            security: 5,
+            install: 6,
+            dev: 7,
+            deploy: 8,
+            unknown: 9
+        };
+        return [
+            ...items
+        ].sort((a, b)=>{
+            const priorityA = phasePriority[a.phase] ?? 10;
+            const priorityB = phasePriority[b.phase] ?? 10;
+            return priorityA - priorityB;
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ./src/mcp/tools/discover-feedback-loops.ts
+/**
+ * MCP tool handler for discovering scripts and CLI tools.
+ */ 
+
+
+
+
+/**
+ * Discovers npm scripts from package.json and CLI tools from GitHub Actions workflows,
+ * mapping them to SDLC feedback loop phases (test, build, lint, format, etc.).
+ */ const discoverFeedbackLoopsHandler = async (args)=>{
+    const dir = args.targetDir || process.cwd();
+    try {
+        // Create gateways
+        const scriptGateway = createScriptDiscoveryGateway();
+        const toolGateway = createToolDiscoveryGateway();
+        const environmentGateway = createEnvironmentGateway();
+        // Adapter for package manager gateway
+        const packageManagerGateway = {
+            async detectPackageManagers (targetDir) {
+                const env = await environmentGateway.detectEnvironment(targetDir);
+                return env.packageManagers;
+            }
+        };
+        // Create use case
+        const useCase = new DiscoverFeedbackLoopsUseCase(scriptGateway, toolGateway, packageManagerGateway);
+        // Execute discovery
+        const result = await useCase.execute({
+            targetDir: dir
+        });
+        const { scripts, tools, packageManager } = result.feedbackLoops;
+        // Group by phase for better readability
+        const scriptsByPhase = scripts.reduce((acc, script)=>{
+            if (!acc[script.phase]) {
+                acc[script.phase] = [];
+            }
+            acc[script.phase].push({
+                name: script.name,
+                command: script.command,
+                mandatory: script.isMandatory
+            });
+            return acc;
+        }, {});
+        const toolsByPhase = tools.reduce((acc, tool)=>{
+            if (!acc[tool.phase]) {
+                acc[tool.phase] = [];
+            }
+            acc[tool.phase].push({
+                name: tool.name,
+                command: tool.fullCommand,
+                mandatory: tool.isMandatory,
+                source: tool.sourceWorkflow
+            });
+            return acc;
+        }, {});
+        const mandatoryScripts = scripts.filter((s)=>s.isMandatory);
+        const mandatoryTools = tools.filter((t)=>t.isMandatory);
+        return successResponse({
+            summary: {
+                totalScripts: scripts.length,
+                totalTools: tools.length,
+                mandatoryScripts: mandatoryScripts.length,
+                mandatoryTools: mandatoryTools.length,
+                packageManager: packageManager || "none detected"
+            },
+            scriptsByPhase,
+            toolsByPhase,
+            message: `Discovered ${scripts.length} package.json script(s) and ${tools.length} CLI tool(s) from workflows`
+        });
+    } catch (error) {
+        return types_errorResponse(`Failed to discover feedback loops: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/discover-workflow-setup-actions.ts
 /**
  * MCP tool handler for discovering setup actions in existing workflows.
@@ -46438,6 +47298,162 @@ function getGlobalWacContext() {
     });
 };
 
+;// CONCATENATED MODULE: ./src/use-cases/validate-instruction-coverage.ts
+/**
+ * Use case for validating instruction coverage of feedback loops
+ */ /**
+ * Use case for validating that repository instructions cover mandatory feedback loops
+ */ class ValidateInstructionCoverageUseCase {
+    discoverFeedbackLoops;
+    instructionGateway;
+    constructor(discoverFeedbackLoops, instructionGateway){
+        this.discoverFeedbackLoops = discoverFeedbackLoops;
+        this.instructionGateway = instructionGateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        // First, discover all feedback loops
+        const discoveryResult = await this.discoverFeedbackLoops.execute({
+            targetDir: input.targetDir
+        });
+        const { scripts, tools, packageManager } = discoveryResult.feedbackLoops;
+        // Analyze instruction coverage
+        const coverage = await this.instructionGateway.analyzeCoverage(input.targetDir, scripts, tools);
+        // Generate suggestions for missing documentation
+        const suggestions = this.generateSuggestions(coverage, packageManager || "npm");
+        return {
+            coverage,
+            hasFullCoverage: coverage.summary.coveragePercentage === 100,
+            suggestions
+        };
+    }
+    generateSuggestions(coverage, packageManager) {
+        const suggestions = [];
+        if (coverage.missingInInstructions.length === 0) {
+            suggestions.push("✅ All mandatory feedback loops are documented in instructions");
+            return suggestions;
+        }
+        suggestions.push(`⚠️  ${coverage.missingInInstructions.length} mandatory feedback loop(s) are not documented:`);
+        suggestions.push("");
+        // Group by phase
+        const byPhase = new Map();
+        for (const item of coverage.missingInInstructions){
+            const existing = byPhase.get(item.phase) || [];
+            existing.push(item);
+            byPhase.set(item.phase, existing);
+        }
+        // Generate suggestions per phase
+        for (const [phase, items] of byPhase.entries()){
+            suggestions.push(`${phase.toUpperCase()} phase:`);
+            for (const item of items){
+                if ("command" in item) {
+                    // It's a script
+                    suggestions.push(`  - Document "${packageManager} run ${item.name}" (runs: ${item.command})`);
+                } else {
+                    // It's a tool
+                    suggestions.push(`  - Document "${item.fullCommand}"`);
+                }
+            }
+            suggestions.push("");
+        }
+        suggestions.push("Consider adding these to .github/copilot-instructions.md");
+        suggestions.push("or creating dedicated instruction files in .github/instructions/");
+        return suggestions;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/mcp/tools/validate-instruction-coverage.ts
+/**
+ * MCP tool handler for validating instruction coverage of feedback loops.
+ */ 
+
+
+
+
+
+
+/**
+ * Validates that repository instructions (.github/copilot-instructions.md and .github/instructions/*.md)
+ * document all mandatory feedback loop scripts and tools.
+ * Returns coverage percentage and suggestions for missing documentation.
+ */ const validateInstructionCoverageHandler = async (args)=>{
+    const dir = args.targetDir || process.cwd();
+    try {
+        // Create gateways
+        const scriptGateway = createScriptDiscoveryGateway();
+        const toolGateway = createToolDiscoveryGateway();
+        const environmentGateway = createEnvironmentGateway();
+        const instructionGateway = createInstructionAnalysisGateway();
+        // Adapter for package manager gateway
+        const packageManagerGateway = {
+            async detectPackageManagers (targetDir) {
+                const env = await environmentGateway.detectEnvironment(targetDir);
+                return env.packageManagers;
+            }
+        };
+        // Create use cases
+        const discoverUseCase = new DiscoverFeedbackLoopsUseCase(scriptGateway, toolGateway, packageManagerGateway);
+        const validateUseCase = new ValidateInstructionCoverageUseCase(discoverUseCase, instructionGateway);
+        // Execute validation
+        const result = await validateUseCase.execute({
+            targetDir: dir
+        });
+        const { coverage, hasFullCoverage, suggestions } = result;
+        // Format missing items for better readability
+        const missing = coverage.missingInInstructions.map((item)=>{
+            if ("command" in item) {
+                // Script
+                return {
+                    type: "script",
+                    name: item.name,
+                    phase: item.phase,
+                    command: item.command
+                };
+            }
+            // Tool
+            return {
+                type: "tool",
+                name: item.name,
+                phase: item.phase,
+                command: item.fullCommand
+            };
+        });
+        // Format documented items
+        const documented = coverage.documentedInInstructions.map((item)=>{
+            if ("command" in item) {
+                // Script
+                return {
+                    type: "script",
+                    name: item.name,
+                    phase: item.phase
+                };
+            }
+            // Tool
+            return {
+                type: "tool",
+                name: item.name,
+                phase: item.phase
+            };
+        });
+        return successResponse({
+            hasFullCoverage,
+            summary: {
+                totalMandatory: coverage.summary.totalMandatory,
+                totalDocumented: coverage.summary.totalDocumented,
+                coveragePercentage: coverage.summary.coveragePercentage
+            },
+            missing,
+            documented,
+            suggestions,
+            message: hasFullCoverage ? "✅ All mandatory feedback loops are documented" : `⚠️  ${coverage.summary.coveragePercentage.toFixed(1)}% coverage - ${missing.length} mandatory items not documented`
+        });
+    } catch (error) {
+        return types_errorResponse(`Failed to validate instruction coverage: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/mcp/tools/index.ts
 /**
  * MCP tool handlers module exports.
@@ -46449,6 +47465,8 @@ function getGlobalWacContext() {
 
 
 
+
+
 ;// CONCATENATED MODULE: ./src/mcp/server.ts
 /**
  * MCP Server for Copilot Setup Steps workflow management.
@@ -46500,6 +47518,18 @@ function getGlobalWacContext() {
         handler: discoverWorkflowSetupActionsHandler,
         inputSchema: targetDirInputSchema
     },
+    {
+        name: "discover_feedback_loops",
+        description: "Discover npm scripts from package.json and CLI tools from GitHub Actions workflows, mapping them to SDLC feedback loop phases (test, build, lint, format, security, etc.)",
+        handler: discoverFeedbackLoopsHandler,
+        inputSchema: targetDirInputSchema
+    },
+    {
+        name: "validate_instruction_coverage",
+        description: "Validate that repository instructions (.github/copilot-instructions.md and .github/instructions/*.md) document all mandatory feedback loop scripts and tools. Returns coverage percentage and suggestions for missing documentation.",
+        handler: validateInstructionCoverageHandler,
+        inputSchema: targetDirInputSchema
+    },
     {
         name: "read_copilot_setup_workflow",
         description: "Read the existing Copilot Setup Steps workflow (copilot-setup-steps.yml or .yaml) from a target directory",