@lousy-agents/mcp 5.13.0 → 5.13.2

package/dist/27.js

@@ -7,10 +7,10 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  FSWatcher: () => (/* binding */ FSWatcher),
   WatchHelper: () => (/* binding */ WatchHelper),
   "default": () => (/* binding */ chokidar),
-  watch: () => (/* binding */ watch),
-  FSWatcher: () => (/* binding */ FSWatcher)
+  watch: () => (/* binding */ watch)
 });
 
 // EXTERNAL MODULE: external "node:events"

package/dist/653.js

@@ -720,7 +720,7 @@ __webpack_require__.d(__webpack_exports__, {
   downloadTemplate: () => (/* reexport */ downloadTemplate)
 });
 
-// UNUSED EXPORTS: startShell, registryProvider
+// UNUSED EXPORTS: registryProvider, startShell
 
 // EXTERNAL MODULE: ../../node_modules/giget/dist/_chunks/libs/nypm.mjs
 var nypm = __webpack_require__(292);

package/dist/962.js

@@ -8,7 +8,7 @@ __webpack_require__.d(__webpack_exports__, {
   digest: () => (/* reexport */ node_digest)
 });
 
-// UNUSED EXPORTS: isEqual, serialize, hash
+// UNUSED EXPORTS: hash, isEqual, serialize
 
 // EXTERNAL MODULE: external "node:crypto"
 var external_node_crypto_ = __webpack_require__(7598);

package/dist/mcp-server.js

@@ -8374,7 +8374,7 @@ const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync($ZodRealError);
 const versions_version = {
     major: 4,
     minor: 4,
-    patch: 2,
+    patch: 3,
 };
 
 ;// CONCATENATED MODULE: ../../node_modules/zod/v4/core/schemas.js
@@ -10097,6 +10097,7 @@ const $ZodFile = /*@__PURE__*/ (/* unused pure expression or super */ null && (c
 })));
 const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
+    inst._zod.optin = "optional";
     inst._zod.parse = (payload, ctx) => {
         if (ctx.direction === "backward") {
             throw new $ZodEncodeError(inst.constructor.name);
@@ -10106,6 +10107,7 @@ const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) =>
             const output = _out instanceof Promise ? _out : Promise.resolve(_out);
             return output.then((output) => {
                 payload.value = output;
+                payload.fallback = true;
                 return payload;
             });
         }
@@ -10113,11 +10115,12 @@ const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) =>
             throw new $ZodAsyncError();
         }
         payload.value = _out;
+        payload.fallback = true;
         return payload;
     };
 });
 function handleOptionalResult(result, input) {
-    if (result.issues.length && input === undefined) {
+    if (input === undefined && (result.issues.length || result.fallback)) {
         return { issues: [], value: undefined };
     }
     return result;
@@ -10135,10 +10138,11 @@ const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
     });
     inst._zod.parse = (payload, ctx) => {
         if (def.innerType._zod.optin === "optional") {
+            const input = payload.value;
             const result = def.innerType._zod.run(payload, ctx);
             if (result instanceof Promise)
-                return result.then((r) => handleOptionalResult(r, payload.value));
-            return handleOptionalResult(result, payload.value);
+                return result.then((r) => handleOptionalResult(r, input));
+            return handleOptionalResult(result, input);
         }
         if (payload.value === undefined) {
             return payload;
@@ -10265,7 +10269,7 @@ const $ZodSuccess = /*@__PURE__*/ (/* unused pure expression or super */ null &&
 })));
 const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+    inst._zod.optin = "optional";
     defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
@@ -10286,6 +10290,7 @@ const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def) => {
                         input: payload.value,
                     });
                     payload.issues = [];
+                    payload.fallback = true;
                 }
                 return payload;
             });
@@ -10300,6 +10305,7 @@ const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def) => {
                 input: payload.value,
             });
             payload.issues = [];
+            payload.fallback = true;
         }
         return payload;
     };
@@ -10346,7 +10352,7 @@ function handlePipeResult(left, next, ctx) {
         left.aborted = true;
         return left;
     }
-    return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+    return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
 }
 const $ZodCodec = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("$ZodCodec", (inst, def) => {
     $ZodType.init(inst, def);
@@ -10404,8 +10410,6 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
 }
 const $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
     $ZodPipe.init(inst, def);
-    defineLazy(inst._zod, "optin", () => def.out._zod.optin);
-    defineLazy(inst._zod, "optout", () => def.out._zod.optout);
 });
 const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
@@ -13992,10 +13996,12 @@ const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
         if (output instanceof Promise) {
             return output.then((output) => {
                 payload.value = output;
+                payload.fallback = true;
                 return payload;
             });
         }
         payload.value = output;
+        payload.fallback = true;
         return payload;
     };
 });
@@ -29484,6 +29490,26 @@ var compat_ZodFirstPartyTypeKind;
     setupActionPatterns: DEFAULT_SETUP_ACTION_PATTERNS,
     packageManagers: DEFAULT_PACKAGE_MANAGERS
 };
+/**
+ * Gets a version type to action name mapping from config.
+ * Returns a partial record as not all types may be configured.
+ */ function getVersionTypeToActionMap(config) {
+    const map = {};
+    for (const action of config.setupActions){
+        map[action.type] = action.action;
+    }
+    return map;
+}
+/**
+ * Gets a version file type to config key mapping from config.
+ * Returns a partial record as not all types may be configured.
+ */ function getVersionFileConfigKeyMap(config) {
+    const map = {};
+    for (const action of config.setupActions){
+        map[action.type] = action.versionFileKey;
+    }
+    return map;
+}
 
 ;// CONCATENATED MODULE: ../core/src/lib/copilot-setup-config.ts
 /**
@@ -29611,29 +29637,8 @@ const CopilotSetupConfigSchema = schemas_object({
  *
  * This function is retained for backwards compatibility but is a no-op
  * because configuration is no longer cached at module scope.
- */ function resetCopilotSetupConfigCache() {
-// no in-memory cache to reset
-}
-/**
- * Gets a version file type to action mapping from config.
- * Returns a partial record as not all types may be configured.
- */ function getVersionTypeToActionMap(config) {
-    const map = {};
-    for (const action of config.setupActions){
-        map[action.type] = action.action;
-    }
-    return map;
-}
-/**
- * Gets a version file type to config key mapping from config.
- * Returns a partial record as not all types may be configured.
- */ function getVersionFileConfigKeyMap(config) {
-    const map = {};
-    for (const action of config.setupActions){
-        map[action.type] = action.versionFileKey;
-    }
-    return map;
-}
+ */ function resetCopilotSetupConfigCache() {}
+
 /**
  * Gets a filename to version type mapping from config.
  */ function getVersionFilenameToTypeMap(config) {
@@ -29995,15 +30000,12 @@ function defaultExec(command, args, options) {
  * 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) {
@@ -30011,7 +30013,6 @@ function defaultExec(command, args, options) {
                     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) {
@@ -30020,14 +30021,12 @@ function defaultExec(command, args, options) {
                 }
             }
         }
-        // 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;
@@ -30046,12 +30045,10 @@ function defaultExec(command, args, options) {
     }
     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 {
@@ -30061,31 +30058,20 @@ function defaultExec(command, args, options) {
                         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
-            }
+            } catch  {}
         }
         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);
@@ -31797,47 +31783,78 @@ const MAX_NPMRC_BYTES = (/* unused pure expression or super */ null && (64 * 102
 
 
 
+
+// 1 MB — covers even the largest real-world manifests
+const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
+const PackageJsonSchema = schemas_object({
+    scripts: record(schemas_string(), schemas_string()).optional()
+});
 /**
  * File system implementation of script discovery gateway
  */ class FileSystemScriptDiscoveryGateway {
+    constructor(logger){
+        this.logger = logger ?? dist_consola;
+    }
+    logger;
     async discoverScripts(targetDir) {
         const packageJsonPath = (0,external_node_path_.join)(targetDir, "package.json");
-        if (!await file_system_utils_fileExists(packageJsonPath)) {
+        let content;
+        try {
+            content = await file_system_utils_readFileNoFollow(packageJsonPath, MAX_PACKAGE_JSON_BYTES);
+        } catch (error) {
+            const code = error instanceof Error && "code" in error ? error.code : undefined;
+            if (code !== "ENOENT") {
+                this.logger.warn(`script-discovery: could not read ${JSON.stringify(packageJsonPath)}: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`);
+            }
             return [];
         }
+        let parsed;
         try {
-            const content = await (0,promises_.readFile)(packageJsonPath, "utf-8");
-            const packageJson = JSON.parse(content);
-            if (!packageJson.scripts) {
+            parsed = JSON.parse(content);
+        } catch (e) {
+            if (e instanceof SyntaxError) {
+                this.logger.warn(`script-discovery: ${JSON.stringify(packageJsonPath)} contains invalid JSON — ${JSON.stringify(e.message)}`);
                 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
+            throw e;
+        }
+        const parseResult = PackageJsonSchema.safeParse(parsed);
+        if (!parseResult.success) {
+            this.logger.warn(`script-discovery: ${JSON.stringify(packageJsonPath)} has an unexpected structure — scripts field must be a record of strings`);
             return [];
         }
+        if (!parseResult.data.scripts) {
+            return [];
+        }
+        const scripts = [];
+        for (const [name, command] of Object.entries(parseResult.data.scripts)){
+            const phase = determineScriptPhase(name, command);
+            const isMandatory = isScriptMandatory(phase);
+            scripts.push({
+                name,
+                command,
+                phase,
+                isMandatory
+            });
+        }
+        return scripts;
     }
 }
 /**
  * Creates and returns the default script discovery gateway
- */ function createScriptDiscoveryGateway() {
-    return new FileSystemScriptDiscoveryGateway();
+ */ function createScriptDiscoveryGateway(logger) {
+    return new FileSystemScriptDiscoveryGateway(logger);
 }
 /**
  * Creates a FeedbackLoopCommandsGateway that discovers mandatory commands from package.json scripts.
- */ function createFeedbackLoopCommandsGateway(scriptGateway) {
-    const gateway = scriptGateway ?? createScriptDiscoveryGateway();
+ *
+ * @param scriptGateway - Optional gateway implementation. If omitted, a default
+ *   `FileSystemScriptDiscoveryGateway` is created using `logger`.
+ * @param logger - Optional logger for the default gateway. Only used when
+ *   `scriptGateway` is omitted; if a custom `scriptGateway` is supplied, its
+ *   own logger configuration applies and this parameter is ignored.
+ */ function createFeedbackLoopCommandsGateway(scriptGateway, logger) {
+    const gateway = scriptGateway ?? createScriptDiscoveryGateway(logger);
     return {
         async getMandatoryCommands (targetDir) {
             const scripts = await gateway.discoverScripts(targetDir);
@@ -32056,9 +32073,7 @@ var yaml_dist = __webpack_require__(3519);
                 const workflow = (0,yaml_dist/* .parse */.qg)(content);
                 const tools = this.extractToolsFromWorkflow(workflow, file);
                 allTools.push(...tools);
-            } catch  {
-            // Skip files that can't be parsed as valid YAML
-            }
+            } catch  {}
         }
         return this.deduplicateTools(allTools);
     }
@@ -32086,7 +32101,6 @@ var yaml_dist = __webpack_require__(3519);
                 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);
                 }
@@ -32096,35 +32110,24 @@ var yaml_dist = __webpack_require__(3519);
     }
     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);
@@ -32163,13 +32166,11 @@ var yaml_dist = __webpack_require__(3519);
         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);
@@ -32426,9 +32427,7 @@ class FileSystemWorkflowGateway {
                 const workflow = (0,yaml_dist/* .parse */.qg)(content);
                 const candidates = extractSetupStepsFromWorkflow(workflow, config.setupActionPatterns);
                 allCandidates.push(...candidates);
-            } catch  {
-            // Skip unreadable or malformed YAML workflow files while continuing scan.
-            }
+            } catch  {}
         }
         return deduplicateCandidates(allCandidates);
     }
@@ -32465,8 +32464,7 @@ function createWorkflowGateway(cwd) {
 ;// CONCATENATED MODULE: ../core/src/gateways/workflow-gateway.ts
 /**
  * Gateway interface for GitHub Actions workflow operations.
- */ // Re-export implementation and factory from the implementation file
-
+ */ 
 
 ;// CONCATENATED MODULE: ../core/src/gateways/index.ts
 /**
@@ -52775,7 +52773,6 @@ Example resolved format: actions/setup-node@1a2b3c4d5e6f  # v4.0.0`;
  * This module handles the logic of determining which GitHub Actions
  * setup steps should be added based on detected version files and package managers.
  */ 
-
 /**
  * Creates an ActionVersionPort backed by a static version map.
  */ function createActionVersionPort(versionMap) {
@@ -53649,11 +53646,8 @@ const workflow_generator_defaultActionVersionPort = createActionVersionPort(work
         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 = {
@@ -53914,14 +53908,11 @@ const workflow_generator_defaultActionVersionPort = createActionVersionPort(work
         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,
@@ -53937,22 +53928,18 @@ const workflow_generator_defaultActionVersionPort = createActionVersionPort(work
         }
         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}"`);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.13.0",
+    "version": "5.13.2",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {
@@ -38,7 +38,7 @@
     "dependencies": {
         "@modelcontextprotocol/sdk": "1.29.0",
         "yaml": "2.8.4",
-        "zod": "4.4.2"
+        "zod": "4.4.3"
     },
     "devDependencies": {
         "@lousy-agents/core": "*"