@lousy-agents/mcp 5.17.15 → 5.18.0

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-1895(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+8454(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -32915,7 +32915,7 @@ function packageImportsResolve(name, base, conditions) {
 			while (++i < keys.length) {
 				const key = keys[i];
 				const patternIndex = key.indexOf("*");
-				if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+				if (patternIndex !== -1 && name.startsWith(key.slice(0, patternIndex))) {
 					const patternTrailer = key.slice(patternIndex + 1);
 					if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
 						bestMatch = key;
@@ -37466,6 +37466,312 @@ const PackageJsonSchema = schemas_object({
     return new FileSystemSkillFileGateway();
 }
 
+;// CONCATENATED MODULE: ../core/src/entities/agentic-location-catalog.ts
+/**
+ * Canonical catalog of agentic construct locations shared by lint and doctor.
+ * Pure data only — no filesystem I/O.
+ */ const agentic_location_catalog_AGENTIC_LOCATION_CATALOG = [
+    // Skill lint roots
+    {
+        id: "skill-github",
+        path: ".github/skills",
+        matchKind: "directory-prefix",
+        primaryConstruct: "skill",
+        lintTarget: "skills",
+        harnessHints: [
+            "copilot"
+        ]
+    },
+    {
+        id: "skill-claude",
+        path: ".claude/skills",
+        matchKind: "directory-prefix",
+        primaryConstruct: "skill",
+        lintTarget: "skills",
+        harnessHints: [
+            "claude"
+        ]
+    },
+    {
+        id: "skill-agents",
+        path: ".agents/skills",
+        matchKind: "directory-prefix",
+        primaryConstruct: "skill",
+        lintTarget: "skills",
+        harnessHints: [
+            "shared"
+        ]
+    },
+    // Doctor-only skill locations
+    {
+        id: "skill-pi",
+        path: ".pi/skills",
+        matchKind: "directory-prefix",
+        primaryConstruct: "skill",
+        lintTarget: "none",
+        harnessHints: [
+            "pi"
+        ]
+    },
+    {
+        id: "skill-pi-prompts",
+        path: ".pi/prompts",
+        matchKind: "directory-prefix",
+        primaryConstruct: "skill",
+        lintTarget: "none",
+        harnessHints: [
+            "pi"
+        ]
+    },
+    // Agent lint root (dual-role: agent + instruction)
+    {
+        id: "agent-github",
+        path: ".github/agents",
+        matchKind: "directory-prefix",
+        primaryConstruct: "agent",
+        secondaryConstructs: [
+            "instruction"
+        ],
+        lintTarget: "agents",
+        harnessHints: [
+            "copilot"
+        ],
+        instructionFormat: "copilot-agent"
+    },
+    // Hook lint exact configs
+    {
+        id: "hook-copilot-agent-shell",
+        path: ".github/hooks/agent-shell/hooks.json",
+        matchKind: "exact",
+        primaryConstruct: "hook",
+        lintTarget: "hooks",
+        harnessHints: [
+            "copilot"
+        ],
+        hookPlatform: "copilot"
+    },
+    {
+        id: "hook-claude-settings",
+        path: ".claude/settings.json",
+        matchKind: "exact",
+        primaryConstruct: "hook",
+        lintTarget: "hooks",
+        harnessHints: [
+            "claude"
+        ],
+        hookPlatform: "claude"
+    },
+    {
+        id: "hook-claude-settings-local",
+        path: ".claude/settings.local.json",
+        matchKind: "exact",
+        primaryConstruct: "hook",
+        lintTarget: "hooks",
+        harnessHints: [
+            "claude"
+        ],
+        hookPlatform: "claude"
+    },
+    // Doctor-only hook directory prefixes
+    {
+        id: "hook-github-dir",
+        path: ".github/hooks",
+        matchKind: "directory-prefix",
+        primaryConstruct: "hook",
+        lintTarget: "none",
+        harnessHints: [
+            "copilot"
+        ]
+    },
+    {
+        id: "hook-claude-dir",
+        path: ".claude/hooks",
+        matchKind: "directory-prefix",
+        primaryConstruct: "hook",
+        lintTarget: "none",
+        harnessHints: [
+            "claude"
+        ]
+    },
+    // Instruction lint locations
+    {
+        id: "instruction-copilot-root",
+        path: ".github/copilot-instructions.md",
+        matchKind: "exact",
+        primaryConstruct: "instruction",
+        lintTarget: "instructions",
+        harnessHints: [
+            "copilot"
+        ],
+        instructionFormat: "copilot-instructions"
+    },
+    {
+        id: "instruction-copilot-scoped",
+        path: ".github/instructions",
+        matchKind: "directory-prefix",
+        primaryConstruct: "instruction",
+        lintTarget: "instructions",
+        harnessHints: [
+            "copilot"
+        ],
+        instructionFormat: "copilot-scoped"
+    },
+    {
+        id: "instruction-agents-md",
+        path: "AGENTS.md",
+        matchKind: "exact",
+        primaryConstruct: "instruction",
+        lintTarget: "instructions",
+        harnessHints: [
+            "shared"
+        ],
+        instructionFormat: "agents-md"
+    },
+    {
+        id: "instruction-claude-md",
+        path: "CLAUDE.md",
+        matchKind: "exact",
+        primaryConstruct: "instruction",
+        lintTarget: "instructions",
+        harnessHints: [
+            "claude"
+        ],
+        instructionFormat: "claude-md"
+    },
+    // Doctor-only construct locations
+    {
+        id: "subagent-claude",
+        path: ".claude/agents",
+        matchKind: "directory-prefix",
+        primaryConstruct: "subagent",
+        lintTarget: "none",
+        harnessHints: [
+            "claude"
+        ]
+    },
+    {
+        id: "agent-claude-commands",
+        path: ".claude/commands",
+        matchKind: "directory-prefix",
+        primaryConstruct: "agent",
+        lintTarget: "none",
+        harnessHints: [
+            "claude"
+        ]
+    },
+    {
+        id: "plugin-codex",
+        path: ".codex-plugin",
+        matchKind: "directory-prefix",
+        primaryConstruct: "plugin",
+        lintTarget: "none",
+        harnessHints: [
+            "codex"
+        ]
+    }
+];
+
+;// CONCATENATED MODULE: ../core/src/lib/agentic-location-matchers.ts
+/**
+ * Pure path→construct matching helpers over the agentic location catalog.
+ * No filesystem I/O.
+ */ 
+/**
+ * Normalizes a repo-relative path for catalog matching.
+ * Collapses `.` / `..` segments. Returns "" when the path is absolute or
+ * escapes the repository root — callers treat "" as non-matching.
+ */ function normalizeRepoRelativePath(path) {
+    const normalized = path.replaceAll("\\", "/");
+    // POSIX absolute, UNC-style leading slash after backslash conversion,
+    // and Windows drive-letter absolute (C:/..., d:\...).
+    if (normalized.startsWith("/") || /^[A-Za-z]:(\/|$)/.test(normalized)) {
+        return "";
+    }
+    const resolved = [];
+    for (const segment of normalized.split("/")){
+        if (segment === "" || segment === ".") {
+            continue;
+        }
+        if (segment === "..") {
+            if (resolved.length === 0) {
+                return "";
+            }
+            resolved.pop();
+            continue;
+        }
+        resolved.push(segment);
+    }
+    return resolved.join("/");
+}
+function matchesLocationEntry(path, entry) {
+    const normalized = normalizeRepoRelativePath(path);
+    if (entry.matchKind === "exact") {
+        return normalized === entry.path;
+    }
+    return normalized === entry.path || normalized.startsWith(`${entry.path}/`);
+}
+function entriesMatchingPath(path, catalog = AGENTIC_LOCATION_CATALOG) {
+    return catalog.filter((entry)=>matchesLocationEntry(path, entry));
+}
+function specificityScore(entry) {
+    // Exact matches outrank any prefix; longer prefixes outrank shorter ones.
+    const kindBonus = entry.matchKind === "exact" ? 1_000_000 : 0;
+    return kindBonus + entry.path.length;
+}
+function bestMatchingEntry(path, catalog = AGENTIC_LOCATION_CATALOG) {
+    const matches = entriesMatchingPath(path, catalog);
+    if (matches.length === 0) {
+        return null;
+    }
+    let best = matches[0];
+    let bestScore = specificityScore(best);
+    for(let i = 1; i < matches.length; i++){
+        const candidate = matches[i];
+        const score = specificityScore(candidate);
+        if (score > bestScore) {
+            best = candidate;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+function primaryConstructTypeForPath(path, catalog = AGENTIC_LOCATION_CATALOG) {
+    return bestMatchingEntry(path, catalog)?.primaryConstruct ?? null;
+}
+function constructTypesForPath(path, catalog = AGENTIC_LOCATION_CATALOG) {
+    const best = bestMatchingEntry(path, catalog);
+    if (!best) {
+        return [];
+    }
+    if (best.secondaryConstructs && best.secondaryConstructs.length > 0) {
+        return [
+            best.primaryConstruct,
+            ...best.secondaryConstructs
+        ];
+    }
+    return [
+        best.primaryConstruct
+    ];
+}
+function lintTargetEntries(target, catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
+    return catalog.filter((entry)=>entry.lintTarget === target);
+}
+function skillDirectoryRoots(catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
+    return lintTargetEntries("skills", catalog).filter((entry)=>entry.matchKind === "directory-prefix").map((entry)=>entry.path);
+}
+function agentDirectoryRoots(catalog = AGENTIC_LOCATION_CATALOG) {
+    return lintTargetEntries("agents", catalog).filter((entry)=>entry.matchKind === "directory-prefix").map((entry)=>entry.path);
+}
+function hookConfigPaths(catalog = AGENTIC_LOCATION_CATALOG) {
+    return lintTargetEntries("hooks", catalog).filter((entry)=>entry.matchKind === "exact" && entry.hookPlatform != null).map((entry)=>({
+            relativePath: entry.path,
+            platform: entry.hookPlatform
+        }));
+}
+function instructionDiscoveryEntries(catalog = agentic_location_catalog_AGENTIC_LOCATION_CATALOG) {
+    return catalog.filter((entry)=>entry.instructionFormat != null);
+}
+
 ;// CONCATENATED MODULE: ../core/src/gateways/skill-lint-gateway.ts
 /**
  * Gateway for skill lint file system operations.
@@ -37474,14 +37780,9 @@ const PackageJsonSchema = schemas_object({
 
 
 
+
 /** Maximum skill file size: 1 MB */ const MAX_SKILL_FILE_BYTES = 1_048_576;
-/**
- * Skill directory locations to search for SKILL.md files.
- */ const SKILL_DIRECTORIES = [
-    (0,external_node_path_.join)(".github", "skills"),
-    (0,external_node_path_.join)(".claude", "skills"),
-    (0,external_node_path_.join)(".agents", "skills")
-];
+/** Catalog skill roots converted to OS-native relative paths. */ const SKILL_DIRECTORIES = skillDirectoryRoots().map((root)=>(0,external_node_path_.join)(...root.split("/")));
 /** Maximum lock file size: 256 KB */ const MAX_LOCK_FILE_BYTES = 262_144;
 /** Relative path to the skills lock file. */ const SKILLS_LOCK_PATH = "skills-lock.json";
 /** Zod schema for skills-lock.json structure */ const SkillsLockSchema = schemas_object({
@@ -38149,40 +38450,28 @@ function createWorkflowGateway(cwd) {
  * Supports GitHub Copilot, Claude Code, and community agent instruction formats.
  */ 
 
+
 /**
  * File system implementation of the instruction file discovery gateway.
  */ class FileSystemInstructionFileDiscoveryGateway {
     async discoverInstructionFiles(targetDir) {
         const files = [];
-        // .github/copilot-instructions.md
-        const copilotInstructions = (0,external_node_path_.join)(".github", "copilot-instructions.md");
-        if (await this.safePathExists(targetDir, copilotInstructions)) {
-            files.push({
-                filePath: (0,external_node_path_.join)(targetDir, copilotInstructions),
-                format: "copilot-instructions"
-            });
-        }
-        // .github/instructions/*.md
-        const instructionsDir = (0,external_node_path_.join)(".github", "instructions");
-        await this.discoverMdFilesInDir(targetDir, instructionsDir, "copilot-scoped", files);
-        // .github/agents/*.md
-        const agentsDir = (0,external_node_path_.join)(".github", "agents");
-        await this.discoverMdFilesInDir(targetDir, agentsDir, "copilot-agent", files);
-        // AGENTS.md at repo root
-        const agentsMd = "AGENTS.md";
-        if (await this.safePathExists(targetDir, agentsMd)) {
-            files.push({
-                filePath: (0,external_node_path_.join)(targetDir, agentsMd),
-                format: "agents-md"
-            });
-        }
-        // CLAUDE.md at repo root
-        const claudeMd = "CLAUDE.md";
-        if (await this.safePathExists(targetDir, claudeMd)) {
-            files.push({
-                filePath: (0,external_node_path_.join)(targetDir, claudeMd),
-                format: "claude-md"
-            });
+        for (const entry of instructionDiscoveryEntries()){
+            const format = entry.instructionFormat;
+            if (format == null) {
+                continue;
+            }
+            const relativePath = (0,external_node_path_.join)(...entry.path.split("/"));
+            if (entry.matchKind === "exact") {
+                if (await this.safePathExists(targetDir, relativePath)) {
+                    files.push({
+                        filePath: (0,external_node_path_.join)(targetDir, relativePath),
+                        format
+                    });
+                }
+                continue;
+            }
+            await this.discoverMdFilesInDir(targetDir, relativePath, format, files);
         }
         return files;
     }
@@ -59889,7 +60178,12 @@ function normalize (uri, options) {
  */
 function resolve (baseURI, relativeURI, options) {
   const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' }
-  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)
+  const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions)
+  const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions)
+  if (baseMalformed || relativeMalformed) {
+    throw new Error(baseParsed.error || relativeParsed.error || 'URI is malformed.')
+  }
+  const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true)
   schemelessOptions.skipEscape = true
   return serialize(resolved, schemelessOptions)
 }
@@ -60069,6 +60363,15 @@ const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:
 // with or without a scheme prefix, for the literal-backslash rejection below.
 const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/
 
+// Captures the leading authority-introducer region after an optional scheme: a
+// run of forward slashes, backslashes, and the characters the WHATWG URL parser
+// removes before parsing (TAB U+0009, LF U+000A, CR U+000D). A valid introducer
+// is exactly "//". Node treats "\" as "/" on special schemes and strips those
+// characters first, so forms like "\\", "/\", "\/", "/<TAB>/", or a leading
+// "<TAB>//" reach an authority in Node while fast-uri's URI_PARSE folds them into
+// the path group (host confusion / SSRF / redirect bypass).
+const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/
+
 /**
  * @param {import('./types/index').URIComponent} parsed
  * @param {RegExpMatchArray} matches
@@ -60128,6 +60431,28 @@ function parseWithStatus (uri, opts) {
     malformedAuthorityOrPort = true
   }
 
+  // Reject a malformed or whitespace-smuggled authority introducer. fast-uri
+  // only recognizes a literal "//"; anything else in the leading separator run
+  // (a backslash, or a "//" that appears only after removing the TAB/LF/CR that
+  // Node strips) means the authority fast-uri parses differs from the one Node's
+  // URL resolves. Reject rather than rewrite, mirroring the literal-backslash
+  // guard above. Percent-encoded forms (%5C, %09) are untouched, valid data.
+  const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION)
+  if (introducerMatch !== null) {
+    const region = introducerMatch[1]
+    const normalizedRegion = region.replace(/[\t\n\r]/g, '')
+    // Two or more leading separators introduce an authority.
+    if (normalizedRegion.length >= 2) {
+      if (normalizedRegion.slice(0, 2) !== '//') {
+        parsed.error = parsed.error || 'URI authority must not contain a literal backslash.'
+        malformedAuthorityOrPort = true
+      } else if (region.length !== normalizedRegion.length) {
+        parsed.error = parsed.error || 'URI authority introducer must not contain whitespace.'
+        malformedAuthorityOrPort = true
+      }
+    }
+  }
+
   const matches = uri.match(URI_PARSE)
 
   if (matches) {
@@ -69568,4 +69893,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(1895);
+var __webpack_exports__ = __webpack_require__(8454);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.17.15",
+    "version": "5.18.0",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {