@lousy-agents/cli 2.4.0 → 2.5.1

package/README.md

@@ -126,8 +126,10 @@ npx @lousy-agents/cli copilot-setup
 |---------|--------|
 | Scaffolding for webapps | ✅ Complete |
 | Scaffolding for REST APIs | ✅ Complete |
-| Scaffolding for CLI | Not Started |
+| Scaffolding for CLI | ✅ Complete |
 | Scaffolding for GraphQL APIs | Not Started |
+| Copilot setup package manager install steps | ✅ Complete |
+| Copilot agent and skill scaffolding | ✅ Complete |
 | MCP server package | ✅ Complete |
 
 ## Documentation

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");
@@ -14291,14 +14291,14 @@ async function watchConfig(options) {
     }
     async detectMise(targetDir) {
         const miseTomlPath = (0,external_node_path_.join)(targetDir, "mise.toml");
-        return fileExists(miseTomlPath);
+        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],
@@ -14333,7 +14333,7 @@ async function watchConfig(options) {
     }
     async detectNodePackageManager(targetDir, nodePackageManagers) {
         const packageJsonPath = (0,external_node_path_.join)(targetDir, "package.json");
-        if (!await fileExists(packageJsonPath)) {
+        if (!await file_system_utils_fileExists(packageJsonPath)) {
             return null;
         }
         // Priority order for Node.js package managers: npm > yarn > pnpm
@@ -14348,7 +14348,7 @@ async function watchConfig(options) {
                 continue;
             }
             const lockfilePath = (0,external_node_path_.join)(targetDir, pmConfig.lockfile);
-            if (await fileExists(lockfilePath)) {
+            if (await file_system_utils_fileExists(lockfilePath)) {
                 return {
                     type: pmConfig.type,
                     filename: pmConfig.manifestFile,
@@ -14375,9 +14375,9 @@ async function watchConfig(options) {
                 continue;
             }
             const manifestPath = (0,external_node_path_.join)(targetDir, pmConfig.manifestFile);
-            if (await fileExists(manifestPath)) {
+            if (await file_system_utils_fileExists(manifestPath)) {
                 const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
-                const hasLockfile = lockfilePath ? await fileExists(lockfilePath) : false;
+                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
                 // Skip if lockfile is required but not present
                 if (pmConfig.requiresLockfile && !hasLockfile) {
                     continue;
@@ -14395,9 +14395,9 @@ async function watchConfig(options) {
         const packageManagers = [];
         for (const pmConfig of otherPackageManagers){
             const manifestPath = (0,external_node_path_.join)(targetDir, pmConfig.manifestFile);
-            if (await fileExists(manifestPath)) {
+            if (await file_system_utils_fileExists(manifestPath)) {
                 const lockfilePath = pmConfig.lockfile ? (0,external_node_path_.join)(targetDir, pmConfig.lockfile) : undefined;
-                const hasLockfile = lockfilePath ? await fileExists(lockfilePath) : false;
+                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
                 // Skip if lockfile is required but not present
                 if (pmConfig.requiresLockfile && !hasLockfile) {
                     continue;
@@ -14418,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.
@@ -14436,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);
@@ -14459,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.
@@ -14682,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;
             }
         }
@@ -14690,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);
@@ -14757,6 +15079,9 @@ var dist = __webpack_require__(1198);
 
 
 
+
+
+
 ;// CONCATENATED MODULE: ./src/use-cases/candidate-builder.ts
 /**
  * Use case for building setup step candidates from environment detection.
@@ -15619,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(", ");
@@ -30511,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;
         }