@lousy-agents/mcp 5.20.2 → 5.21.0

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-4583(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+7444(__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);
@@ -38932,6 +38932,612 @@ function createWorkflowGateway(cwd) {
     }
 };
 
+;// CONCATENATED MODULE: ../core/src/entities/source-position.ts
+/**
+ * Pure helpers for mapping string offsets to 1-based line/column positions.
+ */ /** 1-based line and column within a text document */ /**
+ * Maps a 0-based string offset into a 1-based line and column.
+ * Offsets are clamped to [0, content.length]. Newlines (`\n`) advance the line.
+ */ function offsetToSourcePosition(content, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, content.length));
+    let line = 1;
+    let column = 1;
+    for(let i = 0; i < safeOffset; i++){
+        if (content[i] === "\n") {
+            line += 1;
+            column = 1;
+        } else {
+            column += 1;
+        }
+    }
+    return {
+        line,
+        column
+    };
+}
+
+;// CONCATENATED MODULE: ../core/src/lib/instruction-import-expand.ts
+/**
+ * Pure Claude `@` import expander that builds an ordered EffectiveDocument.
+ */ 
+
+const DEFAULT_MAX_IMPORT_DEPTH = 4;
+const DEFAULT_MAX_UNIQUE_FILES = 64;
+const DEFAULT_MAX_EDGES = 256;
+const DEFAULT_MAX_EMITTED_BYTES = 512_000;
+const DEFAULT_MAX_FILE_BYTES = 1_048_576;
+/** Aligns with doctor HARD_IMPORT: line-start `@path` where path includes `/`. */ const HARD_IMPORT_GLOBAL_RE = /^@([^\s@][^\s]*)/gm;
+const FENCED_CODE_RE = /^(`{3,}|~{3,})[^\r\n]*\r?\n[\s\S]*?^\1[ \t]*$/gm;
+const INLINE_CODE_RE = /`+[^`\r\n]*`+/g;
+function resolveLimits(overrides) {
+    return {
+        maxDepth: overrides?.maxDepth ?? DEFAULT_MAX_IMPORT_DEPTH,
+        maxUniqueFiles: overrides?.maxUniqueFiles ?? DEFAULT_MAX_UNIQUE_FILES,
+        maxEdges: overrides?.maxEdges ?? DEFAULT_MAX_EDGES,
+        maxEmittedBytes: overrides?.maxEmittedBytes ?? DEFAULT_MAX_EMITTED_BYTES,
+        maxFileBytes: overrides?.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES
+    };
+}
+function toPosixRelative(pathValue) {
+    return pathValue.split(external_node_path_.sep).join("/");
+}
+function isInsideCodeRegion(index, regions) {
+    return regions.some((region)=>index >= region.start && index < region.end);
+}
+function collectRegexRanges(content, pattern, skipInside) {
+    const regions = [];
+    for (const match of content.matchAll(pattern)){
+        if (match.index === undefined) {
+            continue;
+        }
+        if (skipInside && isInsideCodeRegion(match.index, skipInside)) {
+            continue;
+        }
+        regions.push({
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    return regions;
+}
+function findCodeRegions(content) {
+    const fenced = collectRegexRanges(content, FENCED_CODE_RE);
+    const inline = collectRegexRanges(content, INLINE_CODE_RE, fenced);
+    return [
+        ...fenced,
+        ...inline
+    ];
+}
+function findImportTokens(content) {
+    const codeRegions = findCodeRegions(content);
+    const tokens = [];
+    for (const match of content.matchAll(HARD_IMPORT_GLOBAL_RE)){
+        if (match.index === undefined) {
+            continue;
+        }
+        const rawTarget = match[1];
+        if (!rawTarget?.includes("/")) {
+            continue;
+        }
+        if (isInsideCodeRegion(match.index, codeRegions)) {
+            continue;
+        }
+        tokens.push({
+            start: match.index,
+            end: match.index + match[0].length,
+            rawTarget
+        });
+    }
+    return tokens;
+}
+function rebaseSegments(segments, offset) {
+    return segments.map((segment)=>({
+            ...segment,
+            effectiveRange: {
+                start: segment.effectiveRange.start + offset,
+                end: segment.effectiveRange.end + offset
+            }
+        }));
+}
+function createLiteralSegment(contentOffset, sourcePath, sourceStart, text, importChain) {
+    if (text.length === 0) {
+        return undefined;
+    }
+    return {
+        effectiveRange: {
+            start: contentOffset,
+            end: contentOffset + text.length
+        },
+        sourcePath,
+        sourceRange: {
+            start: sourceStart,
+            end: sourceStart + text.length
+        },
+        importChain: [
+            ...importChain
+        ]
+    };
+}
+const RULE_ID_BY_STATUS = {
+    unresolved: "instruction/import-unresolved",
+    "not-regular": "instruction/import-unresolved",
+    escape: "instruction/import-escape",
+    absolute: "instruction/import-escape",
+    home: "instruction/import-escape",
+    symlink: "instruction/import-symlink",
+    cycle: "instruction/import-cycle",
+    "depth-exceeded": "instruction/import-depth-exceeded",
+    "size-exceeded": "instruction/import-size-exceeded",
+    resolved: undefined
+};
+const FAILURE_MESSAGE_BY_STATUS = {
+    unresolved: (rawTarget)=>`Import target could not be resolved: ${rawTarget}`,
+    escape: (rawTarget)=>`Import target escapes the repository root: ${rawTarget}`,
+    absolute: (rawTarget)=>`Absolute import paths are not allowed: ${rawTarget}`,
+    home: (rawTarget)=>`Home-directory import paths are not allowed: ${rawTarget}`,
+    symlink: (rawTarget)=>`Import target path contains a symbolic link: ${rawTarget}`,
+    cycle: (rawTarget)=>`Import cycle detected while resolving: ${rawTarget}`,
+    "depth-exceeded": (rawTarget)=>`Import depth limit exceeded while resolving: ${rawTarget}`,
+    "size-exceeded": (rawTarget)=>`Import expansion size or graph limit exceeded while resolving: ${rawTarget}`,
+    "not-regular": (rawTarget)=>`Import target is not a regular file: ${rawTarget}`,
+    resolved: ()=>""
+};
+function ruleIdForStatus(status) {
+    return RULE_ID_BY_STATUS[status];
+}
+function messageForFailure(status, rawTarget) {
+    return FAILURE_MESSAGE_BY_STATUS[status](rawTarget);
+}
+function classifyPathError(error) {
+    if (!(error instanceof Error)) {
+        return "unresolved";
+    }
+    const message = error.message;
+    if (message.includes("outside target directory") || message.includes("invalid-path") || message.includes("outside-workspace")) {
+        return "escape";
+    }
+    if (message.includes("Symlinks are not allowed") || message.includes("symbolic link") || message.includes("path-alias")) {
+        return "symlink";
+    }
+    if (message.includes("exceeds size limit") || message.includes("too-large")) {
+        return "size-exceeded";
+    }
+    return "unresolved";
+}
+function normalizeRelativeWithinRoot(importerRelativePath, rawTarget) {
+    if (rawTarget === "~" || rawTarget.startsWith("~/") || rawTarget.startsWith("~\\")) {
+        return {
+            ok: false,
+            status: "home"
+        };
+    }
+    if ((0,external_node_path_.isAbsolute)(rawTarget)) {
+        return {
+            ok: false,
+            status: "absolute"
+        };
+    }
+    const importerDir = (0,external_node_path_.dirname)(importerRelativePath);
+    const joined = (0,external_node_path_.normalize)((0,external_node_path_.join)(importerDir, rawTarget));
+    const normalized = joined === "." ? "" : joined;
+    if (normalized === ".." || normalized.startsWith(`..${external_node_path_.sep}`) || normalized.startsWith("../") || normalized.startsWith("..\\")) {
+        return {
+            ok: false,
+            status: "escape"
+        };
+    }
+    if (!normalized) {
+        return {
+            ok: false,
+            status: "unresolved"
+        };
+    }
+    return {
+        ok: true,
+        relativePath: toPosixRelative(normalized)
+    };
+}
+function isUnsafeRootPath(rootRelativePath) {
+    return !rootRelativePath || rootRelativePath === ".." || rootRelativePath.startsWith(`..${external_node_path_.sep}`) || rootRelativePath.startsWith("../") || (0,external_node_path_.isAbsolute)(rootRelativePath);
+}
+/**
+ * Owns expansion bookkeeping for a single buildEffectiveDocument call.
+ * Mutations stay on the session instance rather than shared parameter bags.
+ */ class ExpansionSession {
+    limits;
+    contentCache = new Map();
+    uniqueFiles = new Set();
+    edges = [];
+    diagnostics = [];
+    emittedBytes = 0;
+    constructor(limits){
+        this.limits = limits;
+    }
+    get edgeCount() {
+        return this.edges.length;
+    }
+    get remainingEmitBudget() {
+        return this.limits.maxEmittedBytes - this.emittedBytes;
+    }
+    isEmitBudgetExhausted() {
+        return this.emittedBytes >= this.limits.maxEmittedBytes;
+    }
+    snapshot() {
+        return {
+            edges: [
+                ...this.edges
+            ],
+            diagnostics: [
+                ...this.diagnostics
+            ]
+        };
+    }
+    recordEdge(edge) {
+        this.edges.push(edge);
+        // Failures always carry ruleId; resolved edges do not.
+        if (!edge.ruleId) {
+            return;
+        }
+        this.diagnostics.push({
+            ruleId: edge.ruleId,
+            message: messageForFailure(edge.status, edge.rawTarget),
+            filePath: edge.importer,
+            range: edge.tokenRange
+        });
+    }
+    recordFailure(importer, token, status, target) {
+        this.recordEdge({
+            importer,
+            tokenRange: {
+                start: token.start,
+                end: token.end
+            },
+            rawTarget: token.rawTarget,
+            target,
+            status,
+            ruleId: ruleIdForStatus(status)
+        });
+    }
+    recordResolved(importer, token, target) {
+        this.recordEdge({
+            importer,
+            tokenRange: {
+                start: token.start,
+                end: token.end
+            },
+            rawTarget: token.rawTarget,
+            target,
+            status: "resolved"
+        });
+    }
+    /**
+     * Emit up to `text` against the remaining byte budget.
+     * Returns emitted text (possibly clipped) and whether the full text fit.
+     */ takeEmitBudget(text) {
+        if (text.length === 0) {
+            return {
+                emitted: "",
+                complete: true
+            };
+        }
+        const room = this.remainingEmitBudget;
+        if (room <= 0) {
+            return {
+                emitted: "",
+                complete: false
+            };
+        }
+        if (text.length <= room) {
+            this.emittedBytes += text.length;
+            return {
+                emitted: text,
+                complete: true
+            };
+        }
+        this.emittedBytes += room;
+        return {
+            emitted: text.slice(0, room),
+            complete: false
+        };
+    }
+    async readFile(repoRoot, relativePath) {
+        const cached = this.contentCache.get(relativePath);
+        if (cached !== undefined) {
+            return {
+                ok: true,
+                content: cached
+            };
+        }
+        try {
+            await file_system_utils_resolvePathWithinRoot(repoRoot, relativePath);
+        } catch (error) {
+            return {
+                ok: false,
+                status: classifyPathError(error)
+            };
+        }
+        try {
+            const stats = await file_system_utils_statWithinRoot(repoRoot, relativePath);
+            if (stats.isSymbolicLink) {
+                return {
+                    ok: false,
+                    status: "symlink"
+                };
+            }
+            if (!stats.isFile) {
+                return {
+                    ok: false,
+                    status: "not-regular"
+                };
+            }
+        } catch (error) {
+            return {
+                ok: false,
+                status: classifyPathError(error)
+            };
+        }
+        const isNewUnique = !this.uniqueFiles.has(relativePath);
+        if (isNewUnique && this.uniqueFiles.size >= this.limits.maxUniqueFiles) {
+            return {
+                ok: false,
+                status: "size-exceeded"
+            };
+        }
+        try {
+            const content = await file_system_utils_readTextWithinRoot(repoRoot, relativePath, this.limits.maxFileBytes);
+            this.contentCache.set(relativePath, content);
+            if (isNewUnique) {
+                this.uniqueFiles.add(relativePath);
+            }
+            return {
+                ok: true,
+                content
+            };
+        } catch (error) {
+            return {
+                ok: false,
+                status: classifyPathError(error)
+            };
+        }
+    }
+}
+class ContentBuilder {
+    outputText = "";
+    builtSegments = [];
+    get output() {
+        return this.outputText;
+    }
+    get length() {
+        return this.outputText.length;
+    }
+    get segments() {
+        return this.builtSegments;
+    }
+    appendLiteral(sourcePath, sourceStart, text, importChain) {
+        const segment = createLiteralSegment(this.outputText.length, sourcePath, sourceStart, text, importChain);
+        if (!segment) {
+            return;
+        }
+        this.builtSegments.push(segment);
+        this.outputText += text;
+    }
+    appendExpanded(content, segments) {
+        this.outputText += content;
+        this.builtSegments.push(...segments);
+    }
+    toResult() {
+        return {
+            content: this.outputText,
+            segments: [
+                ...this.builtSegments
+            ]
+        };
+    }
+}
+function emitSourceSlice(session, builder, sourcePath, content, from, to, importChain) {
+    if (to <= from) {
+        return true;
+    }
+    const { emitted, complete } = session.takeEmitBudget(content.slice(from, to));
+    builder.appendLiteral(sourcePath, from, emitted, importChain);
+    return complete;
+}
+async function expandToken(session, repoRoot, importerPath, token, hop, stack, importChain, outputOffset) {
+    if (session.edgeCount >= session.limits.maxEdges) {
+        session.recordFailure(importerPath, token, "size-exceeded");
+        return {
+            kind: "unexpanded"
+        };
+    }
+    const nextHop = hop + 1;
+    if (nextHop > session.limits.maxDepth) {
+        session.recordFailure(importerPath, token, "depth-exceeded");
+        return {
+            kind: "unexpanded"
+        };
+    }
+    const normalized = normalizeRelativeWithinRoot(importerPath, token.rawTarget);
+    if (!normalized.ok) {
+        session.recordFailure(importerPath, token, normalized.status);
+        return {
+            kind: "unexpanded"
+        };
+    }
+    const targetPath = normalized.relativePath;
+    if (stack.includes(targetPath)) {
+        session.recordFailure(importerPath, token, "cycle", targetPath);
+        return {
+            kind: "unexpanded"
+        };
+    }
+    const readResult = await session.readFile(repoRoot, targetPath);
+    if (!readResult.ok) {
+        session.recordFailure(importerPath, token, readResult.status, targetPath);
+        return {
+            kind: "unexpanded"
+        };
+    }
+    if (session.isEmitBudgetExhausted()) {
+        session.recordFailure(importerPath, token, "size-exceeded", targetPath);
+        return {
+            kind: "unexpanded"
+        };
+    }
+    const child = await expandContent(session, repoRoot, targetPath, readResult.content, nextHop, [
+        ...stack,
+        targetPath
+    ], [
+        ...importChain,
+        targetPath
+    ]);
+    session.recordResolved(importerPath, token, targetPath);
+    return {
+        kind: "expanded",
+        content: child.content,
+        segments: rebaseSegments(child.segments, outputOffset)
+    };
+}
+async function expandContent(session, repoRoot, sourcePath, content, hop, stack, importChain) {
+    const tokens = findImportTokens(content);
+    const builder = new ContentBuilder();
+    let cursor = 0;
+    for (const token of tokens){
+        const literalOk = emitSourceSlice(session, builder, sourcePath, content, cursor, token.start, importChain);
+        if (!literalOk) {
+            session.recordFailure(sourcePath, token, "size-exceeded");
+            emitSourceSlice(session, builder, sourcePath, content, token.start, content.length, importChain);
+            return builder.toResult();
+        }
+        const expansion = await expandToken(session, repoRoot, sourcePath, token, hop, stack, importChain, builder.length);
+        if (expansion.kind === "expanded") {
+            builder.appendExpanded(expansion.content, expansion.segments);
+        } else {
+            const tokenOk = emitSourceSlice(session, builder, sourcePath, content, token.start, token.end, importChain);
+            if (!tokenOk) {
+                return builder.toResult();
+            }
+        }
+        cursor = token.end;
+    }
+    emitSourceSlice(session, builder, sourcePath, content, cursor, content.length, importChain);
+    return builder.toResult();
+}
+/**
+ * Build an ordered effective document by expanding verified Claude `@` imports.
+ */ async function buildEffectiveDocument(input) {
+    const limits = resolveLimits(input.limits);
+    const rootRelativePath = toPosixRelative((0,external_node_path_.normalize)(input.rootRelativePath));
+    if (isUnsafeRootPath(rootRelativePath)) {
+        throw new Error(`Root path is outside repository root: ${input.rootRelativePath}`);
+    }
+    const session = new ExpansionSession(limits);
+    const rootRead = await session.readFile(input.repoRoot, rootRelativePath);
+    if (!rootRead.ok) {
+        throw new Error(`Unable to read root instruction file ${rootRelativePath}: ${rootRead.status}`);
+    }
+    const expanded = await expandContent(session, input.repoRoot, rootRelativePath, rootRead.content, 0, [
+        rootRelativePath
+    ], [
+        rootRelativePath
+    ]);
+    const snapshot = session.snapshot();
+    return {
+        root: rootRelativePath,
+        content: expanded.content,
+        orderedSegments: expanded.segments,
+        edges: snapshot.edges,
+        expansionDiagnostics: snapshot.diagnostics
+    };
+}
+
+;// CONCATENATED MODULE: ../core/src/gateways/claude-instruction-import-expander.ts
+/**
+ * Adapter that expands Claude `@path` imports via the pure expander library.
+ */ 
+
+
+
+function toRepoRelativePosix(repoRoot, absoluteFilePath) {
+    const relativePath = (0,external_node_path_.relative)(repoRoot, absoluteFilePath);
+    if (relativePath.length === 0 || relativePath.startsWith(`..${external_node_path_.sep}`) || relativePath === ".." || (0,external_node_path_.isAbsolute)(relativePath)) {
+        throw new Error(`Claude instruction path is outside repository root: ${absoluteFilePath}`);
+    }
+    return relativePath.split(external_node_path_.sep).join("/");
+}
+function toAbsolutePath(repoRoot, relativePosixPath) {
+    return (0,external_node_path_.join)(repoRoot, ...relativePosixPath.split("/"));
+}
+async function mapExpansionDiagnostics(repoRoot, diagnostics) {
+    const contentByRelative = new Map();
+    const mapped = [];
+    for (const diagnostic of diagnostics){
+        const absolutePath = toAbsolutePath(repoRoot, diagnostic.filePath);
+        let content = contentByRelative.get(diagnostic.filePath);
+        if (content === undefined) {
+            content = await (0,promises_.readFile)(absolutePath, "utf8");
+            contentByRelative.set(diagnostic.filePath, content);
+        }
+        if (diagnostic.range === undefined) {
+            mapped.push({
+                ruleId: diagnostic.ruleId,
+                message: diagnostic.message,
+                filePath: absolutePath,
+                line: 1,
+                column: 1
+            });
+            continue;
+        }
+        const start = offsetToSourcePosition(content, diagnostic.range.start);
+        const end = offsetToSourcePosition(content, diagnostic.range.end);
+        mapped.push({
+            ruleId: diagnostic.ruleId,
+            message: diagnostic.message,
+            filePath: absolutePath,
+            line: start.line,
+            column: start.column,
+            endLine: end.line,
+            endColumn: end.column
+        });
+    }
+    return mapped;
+}
+function collectResolvedImports(repoRoot, edges) {
+    const resolved = [];
+    const seen = new Set();
+    for (const edge of edges){
+        if (edge.status !== "resolved" || edge.target === undefined) {
+            continue;
+        }
+        const absolute = toAbsolutePath(repoRoot, edge.target);
+        if (seen.has(absolute)) {
+            continue;
+        }
+        seen.add(absolute);
+        resolved.push(absolute);
+    }
+    return resolved;
+}
+/**
+ * Creates the default Claude instruction import expander used by composition roots.
+ */ function createClaudeInstructionImportExpander() {
+    return {
+        async expandClaudeEntrypoint (input) {
+            const rootRelativePath = toRepoRelativePosix(input.repoRoot, input.absoluteFilePath);
+            const document = await buildEffectiveDocument({
+                repoRoot: input.repoRoot,
+                rootRelativePath
+            });
+            const expansionDiagnostics = await mapExpansionDiagnostics(input.repoRoot, document.expansionDiagnostics);
+            return {
+                content: document.content,
+                effectiveRoot: input.absoluteFilePath,
+                resolvedImports: collectResolvedImports(input.repoRoot, document.edges),
+                expansionDiagnostics
+            };
+        }
+    };
+}
+
 ;// CONCATENATED MODULE: ../core/src/gateways/instruction-file-discovery-gateway.ts
 /**
  * Gateway for discovering instruction files across multiple formats.
@@ -57915,10 +58521,12 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
     discoveryGateway;
     astGateway;
     commandsGateway;
-    constructor(discoveryGateway, astGateway, commandsGateway){
+    claudeImportExpander;
+    constructor(discoveryGateway, astGateway, commandsGateway, claudeImportExpander){
         this.discoveryGateway = discoveryGateway;
         this.astGateway = astGateway;
         this.commandsGateway = commandsGateway;
+        this.claudeImportExpander = claudeImportExpander;
     }
     /**
      * Returns true if the given heading-pattern string contains any characters
@@ -58037,13 +58645,19 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
                 diagnostics: []
             };
         }
-        // Analyze each file
+        // Analyze each file (Claude entrypoints use effective import-expanded content)
         const fileStructures = new Map();
         const parsingErrors = [];
+        const importDiagnostics = [];
+        const effectiveDocuments = [];
         for (const file of discoveredFiles){
             try {
-                const structure = await this.astGateway.parseFile(file.filePath);
-                fileStructures.set(file.filePath, structure);
+                const resolved = await this.resolveAnalysisStructure(file, parsed.targetDir);
+                fileStructures.set(file.filePath, resolved.structure);
+                importDiagnostics.push(...resolved.importDiagnostics);
+                if (resolved.provenance !== undefined) {
+                    effectiveDocuments.push(resolved.provenance);
+                }
             } catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown parsing error";
                 parsingErrors.push({
@@ -58068,6 +58682,8 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
                 target: "instruction"
             });
         }
+        // Import-expansion failures (stable ruleIds, importer-token provenance)
+        diagnostics.push(...importDiagnostics);
         // Check each successfully parsed file for missing structural headings
         const sortedFilePaths = Array.from(fileStructures.keys()).sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
         for (const filePath of sortedFilePaths){
@@ -58112,17 +58728,76 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
                 ruleId: "instruction/parse-error"
             });
         }
+        const result = {
+            discoveredFiles,
+            commandScores,
+            overallQualityScore,
+            suggestions,
+            parsingErrors,
+            ...effectiveDocuments.length > 0 ? {
+                effectiveDocuments
+            } : {}
+        };
         return {
-            result: {
-                discoveredFiles,
-                commandScores,
-                overallQualityScore,
-                suggestions,
-                parsingErrors
-            },
+            result,
             diagnostics
         };
     }
+    /**
+     * Resolves the Markdown structure used for content-sensitive rules on one
+     * discovered entrypoint. Claude entrypoints expand verified `@` imports when
+     * an expander is injected; all other formats parse the physical file only.
+     */ async resolveAnalysisStructure(file, targetDir) {
+        if (file.format === "claude-md" && this.claudeImportExpander !== undefined) {
+            const effective = await this.claudeImportExpander.expandClaudeEntrypoint({
+                repoRoot: targetDir,
+                absoluteFilePath: file.filePath
+            });
+            const importDiagnostics = effective.expansionDiagnostics.map((diagnostic)=>AnalyzeInstructionQualityUseCase.toImportLintDiagnostic(diagnostic));
+            importDiagnostics.sort(AnalyzeInstructionQualityUseCase.compareImportDiagnostics);
+            return {
+                structure: this.astGateway.parseContent(effective.content),
+                importDiagnostics,
+                provenance: {
+                    effectiveRoot: effective.effectiveRoot,
+                    resolvedImports: effective.resolvedImports
+                }
+            };
+        }
+        return {
+            structure: await this.astGateway.parseFile(file.filePath),
+            importDiagnostics: []
+        };
+    }
+    static toImportLintDiagnostic(diagnostic) {
+        return {
+            filePath: diagnostic.filePath,
+            line: diagnostic.line,
+            column: diagnostic.column,
+            endLine: diagnostic.endLine,
+            endColumn: diagnostic.endColumn,
+            severity: "warning",
+            message: diagnostic.message,
+            ruleId: diagnostic.ruleId,
+            target: "instruction"
+        };
+    }
+    static compareImportDiagnostics(a, b) {
+        if (a.filePath !== b.filePath) {
+            return a.filePath < b.filePath ? -1 : 1;
+        }
+        if (a.line !== b.line) {
+            return a.line - b.line;
+        }
+        const aCol = a.column ?? 0;
+        const bCol = b.column ?? 0;
+        if (aCol !== bCol) {
+            return aCol - bCol;
+        }
+        const aRule = a.ruleId ?? "";
+        const bRule = b.ruleId ?? "";
+        return aRule < bRule ? -1 : aRule > bRule ? 1 : 0;
+    }
     findBestScore(command, discoveredFiles, fileStructures, headingPatterns, proximityWindow, diagnostics) {
         let bestAnalysis = null;
         let bestComposite = -1;
@@ -58523,6 +59198,7 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
 
 
 
+
 /**
  * Analyzes the structural quality of feedback loop documentation in instruction files.
  * Assesses structural context, execution clarity, and loop completeness.
@@ -58535,7 +59211,7 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
         const discoveryGateway = createInstructionFileDiscoveryGateway();
         const astGateway = createMarkdownAstGateway();
         const commandsGateway = createFeedbackLoopCommandsGateway();
-        const useCase = new AnalyzeInstructionQualityUseCase(discoveryGateway, astGateway, commandsGateway);
+        const useCase = new AnalyzeInstructionQualityUseCase(discoveryGateway, astGateway, commandsGateway, createClaudeInstructionImportExpander());
         const output = await useCase.execute({
             targetDir: dir
         });
@@ -58558,10 +59234,27 @@ const HEADING_PATTERN_DESCRIPTIONS = new Map(Object.entries(HEADING_PATTERN_DESC
             diagnostics: output.diagnostics.map((d)=>({
                     filePath: d.filePath,
                     line: d.line,
+                    ...d.column !== undefined ? {
+                        column: d.column
+                    } : {},
+                    ...d.endLine !== undefined ? {
+                        endLine: d.endLine
+                    } : {},
+                    ...d.endColumn !== undefined ? {
+                        endColumn: d.endColumn
+                    } : {},
                     severity: d.severity,
                     message: d.message,
                     ruleId: d.ruleId
-                }))
+                })),
+            ...output.result.effectiveDocuments !== undefined ? {
+                effectiveDocuments: output.result.effectiveDocuments.map((doc)=>({
+                        effectiveRoot: doc.effectiveRoot,
+                        resolvedImports: [
+                            ...doc.resolvedImports
+                        ]
+                    }))
+            } : {}
         });
     } catch (error) {
         return types_errorResponse(`Failed to analyze instruction quality: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -70391,4 +71084,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__(4583);
+var __webpack_exports__ = __webpack_require__(7444);

package/package.json

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