@lousy-agents/cli 2.9.1 → 2.10.1

package/dist/mcp-server.js

@@ -40951,6 +40951,7 @@ class AjvJsonSchemaValidator {
  *
  * @experimental
  */
+
 /**
  * Experimental task features for low-level MCP servers.
  *
@@ -40984,6 +40985,162 @@ class ExperimentalServerTasks {
     requestStream(request, resultSchema, options) {
         return this._server.requestStream(request, resultSchema, options);
     }
+    /**
+     * Sends a sampling request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+     * before the final result.
+     *
+     * @example
+     * ```typescript
+     * const stream = server.experimental.tasks.createMessageStream({
+     *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+     *     maxTokens: 100
+     * }, {
+     *     onprogress: (progress) => {
+     *         // Handle streaming tokens via progress notifications
+     *         console.log('Progress:', progress.message);
+     *     }
+     * });
+     *
+     * for await (const message of stream) {
+     *     switch (message.type) {
+     *         case 'taskCreated':
+     *             console.log('Task created:', message.task.taskId);
+     *             break;
+     *         case 'taskStatus':
+     *             console.log('Task status:', message.task.status);
+     *             break;
+     *         case 'result':
+     *             console.log('Final result:', message.result);
+     *             break;
+     *         case 'error':
+     *             console.error('Error:', message.error);
+     *             break;
+     *     }
+     * }
+     * ```
+     *
+     * @param params - The sampling request parameters
+     * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    createMessageStream(params, options) {
+        // Access client capabilities via the server
+        const clientCapabilities = this._server.getClientCapabilities();
+        // Capability check - only required when tools/toolChoice are provided
+        if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+            throw new Error('Client does not support sampling tools capability.');
+        }
+        // Message structure validation - always validate tool_use/tool_result pairs.
+        // These may appear even without tools/toolChoice in the current request when
+        // a previous sampling request returned tool_use and this is a follow-up with results.
+        if (params.messages.length > 0) {
+            const lastMessage = params.messages[params.messages.length - 1];
+            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+            const hasToolResults = lastContent.some(c => c.type === 'tool_result');
+            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+            const previousContent = previousMessage
+                ? Array.isArray(previousMessage.content)
+                    ? previousMessage.content
+                    : [previousMessage.content]
+                : [];
+            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');
+            if (hasToolResults) {
+                if (lastContent.some(c => c.type !== 'tool_result')) {
+                    throw new Error('The last message must contain only tool_result content if any is present');
+                }
+                if (!hasPreviousToolUse) {
+                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');
+                }
+            }
+            if (hasPreviousToolUse) {
+                // Extract tool_use IDs from previous message and tool_result IDs from current message
+                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));
+                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));
+                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {
+                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');
+                }
+            }
+        }
+        return this.requestStream({
+            method: 'sampling/createMessage',
+            params
+        }, CreateMessageResultSchema, options);
+    }
+    /**
+     * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+     * and 'taskStatus' messages before the final result.
+     *
+     * @example
+     * ```typescript
+     * const stream = server.experimental.tasks.elicitInputStream({
+     *     mode: 'url',
+     *     message: 'Please authenticate',
+     *     elicitationId: 'auth-123',
+     *     url: 'https://example.com/auth'
+     * }, {
+     *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+     * });
+     *
+     * for await (const message of stream) {
+     *     switch (message.type) {
+     *         case 'taskCreated':
+     *             console.log('Task created:', message.task.taskId);
+     *             break;
+     *         case 'taskStatus':
+     *             console.log('Task status:', message.task.status);
+     *             break;
+     *         case 'result':
+     *             console.log('User action:', message.result.action);
+     *             break;
+     *         case 'error':
+     *             console.error('Error:', message.error);
+     *             break;
+     *     }
+     * }
+     * ```
+     *
+     * @param params - The elicitation request parameters
+     * @param options - Optional request options (timeout, signal, task creation params, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    elicitInputStream(params, options) {
+        // Access client capabilities via the server
+        const clientCapabilities = this._server.getClientCapabilities();
+        const mode = params.mode ?? 'form';
+        // Capability check based on mode
+        switch (mode) {
+            case 'url': {
+                if (!clientCapabilities?.elicitation?.url) {
+                    throw new Error('Client does not support url elicitation.');
+                }
+                break;
+            }
+            case 'form': {
+                if (!clientCapabilities?.elicitation?.form) {
+                    throw new Error('Client does not support form elicitation.');
+                }
+                break;
+            }
+        }
+        // Normalize params to ensure mode is set for form mode (defaults to 'form' per spec)
+        const normalizedParams = mode === 'form' && params.mode === undefined ? { ...params, mode: 'form' } : params;
+        // Cast to ServerRequest needed because TypeScript can't narrow the union type
+        // based on the discriminated 'method' field when constructing the object literal
+        return this.requestStream({
+            method: 'elicitation/create',
+            params: normalizedParams
+        }, ElicitResultSchema, options);
+    }
     /**
      * Gets the current status of a task.
      *
@@ -45828,6 +45985,17 @@ function defaultExec(command, args, options) {
  */ function createScriptDiscoveryGateway() {
     return new FileSystemScriptDiscoveryGateway();
 }
+/**
+ * Creates a FeedbackLoopCommandsGateway that discovers mandatory commands from package.json scripts.
+ */ function createFeedbackLoopCommandsGateway(scriptGateway) {
+    const gateway = scriptGateway ?? createScriptDiscoveryGateway();
+    return {
+        async getMandatoryCommands (targetDir) {
+            const scripts = await gateway.discoverScripts(targetDir);
+            return scripts.filter((s)=>s.isMandatory).map((s)=>s.name);
+        }
+    };
+}
 
 ;// CONCATENATED MODULE: ./src/gateways/skill-file-gateway.ts
 /**
@@ -65618,24 +65786,43 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
                     overallQualityScore: 0,
                     suggestions: [
                         "No agent instruction files found. Supported formats: .github/copilot-instructions.md, .github/instructions/*.md, .github/agents/*.md, AGENTS.md, CLAUDE.md"
-                    ]
+                    ],
+                    parsingErrors: []
                 },
                 diagnostics: []
             };
         }
         // Analyze each file
         const fileStructures = new Map();
+        const parsingErrors = [];
         for (const file of discoveredFiles){
             try {
                 const structure = await this.astGateway.parseFile(file.filePath);
                 fileStructures.set(file.filePath, structure);
-            } catch  {
-            // Skip files that can't be parsed
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown parsing error";
+                parsingErrors.push({
+                    filePath: file.filePath,
+                    error: errorMessage
+                });
             }
         }
+        // Sort parsing errors for deterministic output
+        parsingErrors.sort((a, b)=>a.filePath.localeCompare(b.filePath));
         // Score each mandatory command across all files
         const commandScores = [];
         const diagnostics = [];
+        // Emit diagnostics for parsing errors
+        for (const pe of parsingErrors){
+            diagnostics.push({
+                filePath: pe.filePath,
+                line: 1,
+                severity: "warning",
+                message: `Failed to parse file: ${pe.error}`,
+                ruleId: "instruction/parse-error",
+                target: "instruction"
+            });
+        }
         for (const command of mandatoryCommands){
             const bestAnalysis = this.findBestScore(command, discoveredFiles, fileStructures, headingPatterns, proximityWindow, diagnostics);
             if (bestAnalysis) {
@@ -65663,12 +65850,17 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
         const overallQualityScore = commandScores.length > 0 ? Math.round(commandScores.reduce((sum, s)=>sum + s.compositeScore, 0) / commandScores.length * 100) : 0;
         // Generate suggestions
         const suggestions = this.generateSuggestions(commandScores);
+        if (parsingErrors.length > 0) {
+            const skippedFiles = parsingErrors.map((pe)=>pe.filePath).join(", ");
+            suggestions.push(`${parsingErrors.length} file(s) could not be parsed and were skipped: ${skippedFiles}. Analysis may be incomplete.`);
+        }
         return {
             result: {
                 discoveredFiles,
                 commandScores,
                 overallQualityScore,
-                suggestions
+                suggestions,
+                parsingErrors
             },
             diagnostics
         };
@@ -65903,22 +66095,19 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
 
 
 
+
 /**
  * Analyzes the structural quality of feedback loop documentation in instruction files.
  * Assesses structural context, execution clarity, and loop completeness.
  */ const analyzeInstructionQualityHandler = async (args)=>{
     const dir = args.targetDir || process.cwd();
+    if (!await file_system_utils_fileExists(dir)) {
+        return types_errorResponse(`Target directory does not exist: ${dir}`);
+    }
     try {
         const discoveryGateway = createInstructionFileDiscoveryGateway();
         const astGateway = createMarkdownAstGateway();
-        // Simple commands gateway that discovers npm scripts
-        const scriptGateway = createScriptDiscoveryGateway();
-        const commandsGateway = {
-            async getMandatoryCommands (targetDir) {
-                const scripts = await scriptGateway.discoverScripts(targetDir);
-                return scripts.filter((s)=>s.isMandatory).map((s)=>s.name);
-            }
-        };
+        const commandsGateway = createFeedbackLoopCommandsGateway();
         const useCase = new AnalyzeInstructionQualityUseCase(discoveryGateway, astGateway, commandsGateway);
         const output = await useCase.execute({
             targetDir: dir
@@ -65938,6 +66127,7 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
                 })),
             overallQualityScore: output.result.overallQualityScore,
             suggestions: output.result.suggestions,
+            parsingErrors: output.result.parsingErrors,
             diagnostics: output.diagnostics.map((d)=>({
                     filePath: d.filePath,
                     line: d.line,