norn-cli 1.4.0 → 1.4.2

package/out/chatParticipant.js

@@ -0,0 +1,722 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerChatParticipant = registerChatParticipant;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const nornPrompt_1 = require("./nornPrompt");
+const swaggerParser_1 = require("./swaggerParser");
+const sequenceRunner_1 = require("./sequenceRunner");
+const parser_1 = require("./parser");
+const environmentProvider_1 = require("./environmentProvider");
+const httpClient_1 = require("./httpClient");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Maximum character budget for file contents sent as LLM context. */
+const MAX_CONTEXT_CHARS = 30_000;
+// ---------------------------------------------------------------------------
+// Tool definitions — inline tools the LLM can call to edit/create files
+// ---------------------------------------------------------------------------
+const NORN_TOOLS = [
+    {
+        name: 'norn_applyEdit',
+        description: 'Apply an edit to the user\'s currently open Norn file (.norn, .nornapi, or .nornenv). ' +
+            'Can replace specific text, insert at a line, or append to the end of the file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['replace', 'insert', 'append'],
+                    description: 'The type of edit: "replace" finds and replaces text, "insert" adds before a line number, "append" adds to end of file',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The new content to insert, append, or use as the replacement',
+                },
+                searchText: {
+                    type: 'string',
+                    description: 'For "replace" action only: the exact text to find in the file and replace with content',
+                },
+                line: {
+                    type: 'number',
+                    description: 'For "insert" action only: the 1-based line number to insert before',
+                },
+            },
+            required: ['action', 'content'],
+        },
+    },
+    {
+        name: 'norn_createFile',
+        description: 'Create a new Norn file (.norn, .nornapi, or .nornenv) in the same directory as the currently open file, or in the workspace root.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filename: {
+                    type: 'string',
+                    description: 'The filename to create (e.g., "my-test.norn", "api.nornapi", ".nornenv"). Relative to the current file\'s directory.',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The full content for the new file',
+                },
+            },
+            required: ['filename', 'content'],
+        },
+    },
+    {
+        name: 'norn_readWorkspaceFile',
+        description: 'Read the contents of a Norn file (.norn, .nornapi, or .nornenv) from the workspace. ' +
+            'Use this to inspect existing tests, API definitions, or environment configurations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'A filename or glob pattern to search for (e.g., "login.norn", "*.nornapi", "shared/*.norn"). Relative to workspace root.',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'norn_getDiagnostics',
+        description: 'Get the current diagnostics (errors and warnings) for Norn files in the workspace. ' +
+            'Use this to understand what problems exist so you can help fix them.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'Optional: a specific file path to get diagnostics for. If omitted, returns diagnostics for all open Norn files.',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'norn_readSwagger',
+        description: 'Fetch and parse an OpenAPI/Swagger specification from a URL. Returns the API title, version, base URL, and a list of endpoints grouped by section/tag. ' +
+            'Use this to understand an API before generating tests.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL of the Swagger/OpenAPI JSON spec (e.g., "https://petstore.swagger.io/v2/swagger.json")',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'norn_runTest',
+        description: 'Run a Norn test sequence from a file in the workspace and return the results. ' +
+            'Use this to verify that a test passes, check assertion results, or debug failures. ' +
+            'IMPORTANT: If the .nornenv has environment-specific variables (under [env:name] sections), ' +
+            'you MUST pass the "environment" parameter with the exact env name (e.g., "dev", "prod") ' +
+            'for those variables to resolve. Each call is independent — switching environments between runs requires passing the env name each time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'Path to the .norn file containing the test sequence. Relative to workspace root.',
+                },
+                sequenceName: {
+                    type: 'string',
+                    description: 'Optional: the name of a specific sequence to run. If omitted, runs the first test sequence found.',
+                },
+                environment: {
+                    type: 'string',
+                    description: 'The environment name from the .nornenv file to use (e.g., "dev", "prod", "staging"). ' +
+                        'Pass this to ensure environment-specific variables resolve correctly. ' +
+                        'If omitted, auto-selects the first available environment.',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+/**
+ * Registers the @norn Copilot Chat participant.
+ *
+ * Gracefully handles the case where GitHub Copilot is not installed —
+ * the rest of the extension continues to work normally.
+ */
+function registerChatParticipant(context) {
+    try {
+        if (!vscode.chat?.createChatParticipant) {
+            // vscode.chat API not available (Copilot not installed or old VS Code)
+            return;
+        }
+        const participant = vscode.chat.createChatParticipant('norn.chat', nornChatHandler);
+        participant.iconPath = vscode.Uri.joinPath(context.extensionUri, 'images', 'icon.png');
+        participant.followupProvider = {
+            provideFollowups(result, _context, _token) {
+                const meta = result.metadata;
+                if (meta?.command === 'generate') {
+                    return [
+                        { prompt: 'Add assertions for the response', label: 'Add assertions' },
+                        { prompt: 'Make this a parameterized test with @data', label: 'Parameterize' },
+                    ];
+                }
+                if (meta?.command === 'explain') {
+                    return [
+                        { prompt: 'How can I improve this test?', label: 'Improve test' },
+                        { prompt: 'What assertions should I add?', label: 'Suggest assertions' },
+                    ];
+                }
+                // General follow-ups
+                return [
+                    { prompt: 'Show me how to write assertions', label: 'Assertion examples' },
+                    { prompt: 'How do I set up environments?', label: 'Environment setup' },
+                    { prompt: 'How do I run tests in CI/CD?', label: 'CLI / CI usage' },
+                ];
+            }
+        };
+        context.subscriptions.push(participant);
+    }
+    catch {
+        // Chat API not available — silently continue
+        console.log('Norn: Chat participant not registered (GitHub Copilot may not be installed)');
+    }
+}
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+const MAX_TOOL_ROUNDS = 5; // safety limit to prevent infinite tool-call loops
+const nornChatHandler = async (request, context, stream, token) => {
+    const command = request.command; // 'generate' | 'explain' | 'convert' | undefined
+    // Build the prompt messages
+    const messages = [];
+    // 1. Norn system-level grounding (sent as User role — LM API has no System role)
+    messages.push(vscode.LanguageModelChatMessage.User(nornPrompt_1.NORN_SYSTEM_PROMPT));
+    // 2. Conversation history — include prior turns for multi-turn context
+    for (const turn of context.history) {
+        if (turn instanceof vscode.ChatRequestTurn) {
+            messages.push(vscode.LanguageModelChatMessage.User(turn.prompt));
+        }
+        else if (turn instanceof vscode.ChatResponseTurn) {
+            const text = turn.response
+                .map(part => (part instanceof vscode.ChatResponseMarkdownPart ? part.value.value : ''))
+                .join('');
+            if (text) {
+                messages.push(vscode.LanguageModelChatMessage.Assistant(text));
+            }
+        }
+    }
+    // 3. Active editor context — include the user's current file if it's a Norn file
+    const activeFileContext = getActiveNornFileContext();
+    if (activeFileContext) {
+        messages.push(vscode.LanguageModelChatMessage.User(activeFileContext.prompt));
+        stream.reference(activeFileContext.uri);
+    }
+    // 4. Build the user prompt based on the slash command
+    const userPrompt = buildUserPrompt(command, request.prompt);
+    messages.push(vscode.LanguageModelChatMessage.User(userPrompt));
+    // Show progress
+    stream.progress('Thinking...');
+    // Request options — include tools so the LLM can edit/create files
+    const requestOptions = {
+        tools: NORN_TOOLS,
+    };
+    // Tool-calling loop: the LLM may request tool calls, we execute them and feed results back
+    try {
+        for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+            if (token.isCancellationRequested) {
+                break;
+            }
+            const chatResponse = await request.model.sendRequest(messages, requestOptions, token);
+            // Collect text and tool calls from the response stream
+            const toolCalls = [];
+            let hasText = false;
+            for await (const part of chatResponse.stream) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                if (part instanceof vscode.LanguageModelTextPart) {
+                    stream.markdown(part.value);
+                    hasText = true;
+                }
+                else if (part instanceof vscode.LanguageModelToolCallPart) {
+                    toolCalls.push(part);
+                }
+            }
+            // If no tool calls or cancelled, we're done
+            if (toolCalls.length === 0 || token.isCancellationRequested) {
+                break;
+            }
+            // Add assistant message with the tool calls to conversation
+            messages.push(vscode.LanguageModelChatMessage.Assistant(toolCalls));
+            // Execute each tool call and feed results back
+            for (const toolCall of toolCalls) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                const result = await executeNornTool(toolCall, stream);
+                messages.push(vscode.LanguageModelChatMessage.User([
+                    new vscode.LanguageModelToolResultPart(toolCall.callId, [
+                        new vscode.LanguageModelTextPart(result),
+                    ]),
+                ]));
+            }
+        }
+    }
+    catch (err) {
+        handleLlmError(err, stream);
+    }
+    return { metadata: { command } };
+};
+async function executeNornTool(toolCall, stream) {
+    switch (toolCall.name) {
+        case 'norn_applyEdit':
+            return executeApplyEdit(toolCall.input, stream);
+        case 'norn_createFile':
+            return executeCreateFile(toolCall.input, stream);
+        case 'norn_readWorkspaceFile':
+            return executeReadWorkspaceFile(toolCall.input, stream);
+        case 'norn_getDiagnostics':
+            return executeGetDiagnostics(toolCall.input, stream);
+        case 'norn_readSwagger':
+            return executeReadSwagger(toolCall.input, stream);
+        case 'norn_runTest':
+            return executeRunTest(toolCall.input, stream);
+        default:
+            return `Unknown tool: ${toolCall.name}`;
+    }
+}
+async function executeApplyEdit(input, stream) {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+        return 'Error: No active editor. Please open a .norn, .nornapi, or .nornenv file first.';
+    }
+    const doc = editor.document;
+    const lang = doc.languageId;
+    if (lang !== 'norn' && lang !== 'nornapi' && lang !== 'nornenv') {
+        return `Error: Active file is not a Norn file (it's "${lang}"). Please open a .norn, .nornapi, or .nornenv file.`;
+    }
+    const edit = new vscode.WorkspaceEdit();
+    switch (input.action) {
+        case 'replace': {
+            if (!input.searchText) {
+                return 'Error: "replace" action requires "searchText" to find the text to replace.';
+            }
+            const text = doc.getText();
+            const idx = text.indexOf(input.searchText);
+            if (idx === -1) {
+                return `Error: Could not find the text to replace. The searchText was not found in the file.`;
+            }
+            // Warn if the searchText matches more than one location
+            const secondIdx = text.indexOf(input.searchText, idx + 1);
+            if (secondIdx !== -1) {
+                return `Error: The searchText was found multiple times in the file. Please provide more specific text that uniquely identifies the location to replace.`;
+            }
+            const startPos = doc.positionAt(idx);
+            const endPos = doc.positionAt(idx + input.searchText.length);
+            edit.replace(doc.uri, new vscode.Range(startPos, endPos), input.content);
+            break;
+        }
+        case 'insert': {
+            const lineNum = (input.line ?? 1) - 1; // convert to 0-based
+            const clampedLine = Math.max(0, Math.min(lineNum, doc.lineCount));
+            const position = new vscode.Position(clampedLine, 0);
+            const contentWithNewline = input.content.endsWith('\n') ? input.content : input.content + '\n';
+            edit.insert(doc.uri, position, contentWithNewline);
+            break;
+        }
+        case 'append': {
+            const lastLine = doc.lineCount - 1;
+            const lastChar = doc.lineAt(lastLine).text.length;
+            const position = new vscode.Position(lastLine, lastChar);
+            const prefix = lastChar > 0 ? '\n' : '';
+            edit.insert(doc.uri, position, prefix + input.content);
+            break;
+        }
+        default:
+            return `Error: Unknown action "${input.action}". Use "replace", "insert", or "append".`;
+    }
+    const success = await vscode.workspace.applyEdit(edit);
+    if (!success) {
+        return 'Error: Failed to apply the edit. The file may be read-only.';
+    }
+    stream.progress('Applied edit to ' + path.basename(doc.uri.fsPath));
+    return `Successfully applied ${input.action} edit to ${path.basename(doc.uri.fsPath)}.`;
+}
+async function executeCreateFile(input, stream) {
+    // Determine the directory: use the active file's directory, or workspace root
+    let targetDir;
+    const activeEditor = vscode.window.activeTextEditor;
+    if (activeEditor) {
+        targetDir = vscode.Uri.file(path.dirname(activeEditor.document.uri.fsPath));
+    }
+    else {
+        const workspaceFolders = vscode.workspace.workspaceFolders;
+        if (!workspaceFolders || workspaceFolders.length === 0) {
+            return 'Error: No workspace folder open and no active file. Cannot determine where to create the file.';
+        }
+        targetDir = workspaceFolders[0].uri;
+    }
+    const fileUri = vscode.Uri.joinPath(targetDir, input.filename);
+    // Check if file already exists
+    try {
+        await vscode.workspace.fs.stat(fileUri);
+        return `Error: File "${input.filename}" already exists at ${fileUri.fsPath}. Use norn_applyEdit to modify existing files.`;
+    }
+    catch {
+        // File doesn't exist — good, we can create it
+    }
+    await vscode.workspace.fs.writeFile(fileUri, Buffer.from(input.content, 'utf8'));
+    // Open the newly created file
+    const doc = await vscode.workspace.openTextDocument(fileUri);
+    await vscode.window.showTextDocument(doc, { preview: false });
+    stream.progress('Created ' + input.filename);
+    return `Successfully created file "${input.filename}" at ${fileUri.fsPath} and opened it in the editor.`;
+}
+async function executeReadWorkspaceFile(input, stream) {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+        return 'Error: No workspace folder open.';
+    }
+    // Search for files matching the pattern — normalize to avoid double `**/` prefixes
+    const rawPattern = input.pattern.replace(/^\/+/, ''); // strip leading slashes
+    const pattern = rawPattern.startsWith('**/') ? rawPattern : `**/${rawPattern}`;
+    const files = await vscode.workspace.findFiles(pattern, '**/node_modules/**', 10);
+    if (files.length === 0) {
+        return `No files found matching pattern "${pattern}". Try a different pattern like "*.norn" or "tests/**/*.norn".`;
+    }
+    const results = [];
+    let totalSize = 0;
+    for (const fileUri of files) {
+        if (totalSize >= MAX_CONTEXT_CHARS) {
+            results.push(`\n... (${files.length - results.length} more files truncated to stay within size limits)`);
+            break;
+        }
+        const bytes = await vscode.workspace.fs.readFile(fileUri);
+        const content = Buffer.from(bytes).toString('utf8');
+        const relativePath = vscode.workspace.asRelativePath(fileUri);
+        if (totalSize + content.length > MAX_CONTEXT_CHARS) {
+            const remaining = MAX_CONTEXT_CHARS - totalSize;
+            results.push(`--- ${relativePath} (truncated) ---\n${content.substring(0, remaining)}\n...`);
+            totalSize = MAX_CONTEXT_CHARS;
+        }
+        else {
+            results.push(`--- ${relativePath} ---\n${content}`);
+            totalSize += content.length;
+        }
+    }
+    stream.progress(`Read ${Math.min(files.length, results.length)} file(s)`);
+    return results.join('\n\n');
+}
+async function executeGetDiagnostics(input, _stream) {
+    const allDiagnostics = vscode.languages.getDiagnostics();
+    const nornExtensions = ['.norn', '.nornapi', '.nornenv'];
+    const relevantDiagnostics = [];
+    for (const [uri, diagnostics] of allDiagnostics) {
+        const filePath = uri.fsPath;
+        const isNornFile = nornExtensions.some(ext => filePath.endsWith(ext));
+        if (!isNornFile) {
+            continue;
+        }
+        // If a specific file was requested, filter to just that file
+        if (input.filePath && !filePath.endsWith(input.filePath) && !filePath.includes(input.filePath)) {
+            continue;
+        }
+        if (diagnostics.length > 0) {
+            relevantDiagnostics.push({
+                file: vscode.workspace.asRelativePath(uri),
+                diagnostics,
+            });
+        }
+    }
+    if (relevantDiagnostics.length === 0) {
+        return input.filePath
+            ? `No diagnostics found for "${input.filePath}". The file may have no errors or warnings.`
+            : 'No diagnostics found for any Norn files. Everything looks clean!';
+    }
+    const lines = [];
+    for (const { file, diagnostics } of relevantDiagnostics) {
+        lines.push(`## ${file}`);
+        for (const d of diagnostics) {
+            const severity = d.severity === vscode.DiagnosticSeverity.Error ? 'ERROR'
+                : d.severity === vscode.DiagnosticSeverity.Warning ? 'WARNING'
+                    : 'INFO';
+            lines.push(`  Line ${d.range.start.line + 1}: [${severity}] ${d.message}`);
+        }
+    }
+    return lines.join('\n');
+}
+async function executeReadSwagger(input, stream) {
+    try {
+        stream.progress('Fetching Swagger spec...');
+        const spec = await (0, swaggerParser_1.parseSwaggerSpec)(input.url);
+        const lines = [
+            `# ${spec.title} v${spec.version}`,
+            `Base URL: ${spec.baseUrl}`,
+            '',
+        ];
+        for (const section of spec.sections) {
+            lines.push(`## ${section.name}`);
+            if (section.description) {
+                lines.push(section.description);
+            }
+            for (const endpoint of section.endpoints) {
+                const params = endpoint.parameters.length > 0
+                    ? ` (params: ${endpoint.parameters.join(', ')})`
+                    : '';
+                lines.push(`  ${endpoint.method.toUpperCase()} ${endpoint.path}${params}${endpoint.name ? ` — ${endpoint.name}` : ''}`);
+            }
+            lines.push('');
+        }
+        stream.progress('Parsed Swagger spec');
+        return lines.join('\n');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error fetching Swagger spec from "${input.url}": ${message}`;
+    }
+}
+async function executeRunTest(input, stream) {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+        return 'Error: No workspace folder open.';
+    }
+    // Resolve the file path
+    const workspaceRoot = workspaceFolders[0].uri.fsPath;
+    const absolutePath = path.isAbsolute(input.filePath)
+        ? input.filePath
+        : path.resolve(workspaceRoot, input.filePath);
+    // Read the file
+    let fileContent;
+    try {
+        const uri = vscode.Uri.file(absolutePath);
+        const bytes = await vscode.workspace.fs.readFile(uri);
+        fileContent = Buffer.from(bytes).toString('utf8');
+    }
+    catch {
+        return `Error: Could not read file "${input.filePath}". Make sure the path is correct.`;
+    }
+    // Extract sequences
+    const sequences = (0, sequenceRunner_1.extractSequences)(fileContent);
+    if (sequences.length === 0) {
+        return `No sequences found in "${input.filePath}". Make sure the file contains a "sequence" or "test sequence" block.`;
+    }
+    // Find the target sequence
+    let target;
+    if (input.sequenceName) {
+        const found = sequences.find(s => s.name.toLowerCase() === input.sequenceName.toLowerCase());
+        if (!found) {
+            const available = sequences.map(s => s.name).join(', ');
+            return `Sequence "${input.sequenceName}" not found. Available sequences: ${available}`;
+        }
+        target = found;
+    }
+    else {
+        // Pick the first test sequence, or first sequence if none are tests
+        target = sequences.find(s => s.isTest) ?? sequences[0];
+    }
+    // Gather variables and environment
+    const fileDir = path.dirname(absolutePath);
+    // Ensure an environment is active so env-specific variables (e.g. baseUrl) resolve.
+    // Priority: explicit input.environment > already-active env > first available env.
+    const previousEnv = (0, environmentProvider_1.getActiveEnvironment)();
+    const effectiveEnv = input.environment
+        ?? previousEnv
+        ?? (0, environmentProvider_1.getAvailableEnvironments)(absolutePath)[0]; // auto-pick first if nothing is set
+    if (effectiveEnv && effectiveEnv !== previousEnv) {
+        (0, environmentProvider_1.setActiveEnvironment)(effectiveEnv);
+    }
+    const envVars = (0, environmentProvider_1.getEnvironmentVariables)(absolutePath);
+    const fileVars = (0, parser_1.extractVariables)(fileContent);
+    const allVariables = { ...envVars, ...fileVars };
+    // Resolve imports for header groups and endpoints
+    const importResult = await (0, parser_1.resolveImports)(fileContent, fileDir, async (p) => {
+        const bytes = await vscode.workspace.fs.readFile(vscode.Uri.file(p));
+        return Buffer.from(bytes).toString('utf8');
+    });
+    // Combine imported variables
+    const importedVars = (0, parser_1.extractVariables)(importResult.importedContent);
+    Object.assign(allVariables, importedVars);
+    const apiDefinitions = importResult.headerGroups.length > 0 || importResult.endpoints.length > 0
+        ? { headerGroups: importResult.headerGroups, endpoints: importResult.endpoints }
+        : undefined;
+    const cookieJar = (0, httpClient_1.createCookieJar)();
+    // Restore original environment after gathering variables
+    if (effectiveEnv !== previousEnv) {
+        (0, environmentProvider_1.setActiveEnvironment)(previousEnv);
+    }
+    // Run the sequence
+    // Report which environment is active for transparency
+    const availableEnvs = (0, environmentProvider_1.getAvailableEnvironments)(absolutePath);
+    stream.progress(`Running "${target.name}" with env: ${effectiveEnv ?? 'none'}...`);
+    try {
+        const result = await (0, sequenceRunner_1.runSequenceWithJar)(target.content, allVariables, cookieJar, fileDir, fileContent, undefined, // no progress callback
+        undefined, // no call stack
+        undefined, // no sequence args
+        apiDefinitions, undefined, // no tag filter
+        importResult.sequenceSources);
+        // Format the results
+        const lines = [
+            `# Test Result: ${result.name || target.name}`,
+            `**Environment**: ${effectiveEnv ?? 'none'} (available: ${availableEnvs.length > 0 ? availableEnvs.join(', ') : 'no .nornenv found'})`,
+            `**Status**: ${result.success ? 'PASSED ✅' : 'FAILED ❌'}`,
+            `**Duration**: ${result.duration}ms`,
+            '',
+        ];
+        // If there were unresolved variables, flag them for debugging
+        const unresolvedVars = Object.entries(allVariables).length === 0 && availableEnvs.length > 0;
+        if (unresolvedVars) {
+            lines.push('⚠️ **Warning**: No variables were resolved. Make sure you pass the `environment` parameter matching one of: ' + availableEnvs.join(', '));
+            lines.push('');
+        }
+        // Assertion results
+        if (result.assertionResults.length > 0) {
+            lines.push('## Assertions');
+            for (const a of result.assertionResults) {
+                const icon = a.passed ? '✅' : '❌';
+                lines.push(`  ${icon} ${a.expression}`);
+                if (!a.passed && a.error) {
+                    lines.push(`     → ${a.error}`);
+                }
+            }
+            lines.push('');
+        }
+        // HTTP responses summary
+        if (result.responses.length > 0) {
+            lines.push('## HTTP Responses');
+            for (let i = 0; i < result.responses.length; i++) {
+                const r = result.responses[i];
+                lines.push(`  ${i + 1}. ${r.status} ${r.statusText} (${r.duration}ms)`);
+            }
+            lines.push('');
+        }
+        // Errors
+        if (result.errors.length > 0) {
+            lines.push('## Errors');
+            for (const e of result.errors) {
+                lines.push(`  ❌ ${e}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const envInfo = availableEnvs.length > 0
+            ? ` (environment: ${effectiveEnv ?? 'none'}, available: ${availableEnvs.join(', ')})`
+            : '';
+        return `Error running sequence "${target.name}"${envInfo}: ${message}`;
+    }
+}
+function getActiveNornFileContext() {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+        return undefined;
+    }
+    const doc = editor.document;
+    const lang = doc.languageId;
+    if (lang !== 'norn' && lang !== 'nornapi' && lang !== 'nornenv') {
+        return undefined;
+    }
+    const text = doc.getText();
+    // Skip very large files to stay within token budget
+    if (text.length > MAX_CONTEXT_CHARS) {
+        const truncated = text.substring(0, MAX_CONTEXT_CHARS);
+        return {
+            prompt: `The user has the following .${lang} file open (truncated):\n\`\`\`${lang}\n${truncated}\n\`\`\``,
+            uri: doc.uri,
+        };
+    }
+    return {
+        prompt: `The user has the following .${lang} file open:\n\`\`\`${lang}\n${text}\n\`\`\``,
+        uri: doc.uri,
+    };
+}
+/**
+ * Build the final user prompt, adjusting instructions based on the slash command.
+ */
+function buildUserPrompt(command, prompt) {
+    switch (command) {
+        case 'generate':
+            return [
+                'The user wants you to generate Norn code. Based on their description, produce a complete, valid .norn snippet.',
+                'Include appropriate assertions (status, body values, types) and use best practices.',
+                'If the description mentions an API or endpoint, generate a test sequence with realistic assertions.',
+                'Wrap the output in ```norn code fences.',
+                '',
+                `User description: ${prompt}`,
+            ].join('\n');
+        case 'explain':
+            return [
+                'The user wants you to explain Norn code. Analyze the code in their active file (provided above) or in their message.',
+                'Explain step by step what the code does, covering: requests, variable assignments, assertions, control flow, and any imports.',
+                'If there are potential issues or improvements, mention them.',
+                '',
+                `User request: ${prompt || 'Explain the current file'}`,
+            ].join('\n');
+        case 'convert':
+            return [
+                'The user wants to convert something to Norn syntax. This could be:',
+                '- A cURL command → .norn request',
+                '- A Postman collection snippet → .norn file',
+                '- Raw HTTP → .norn request',
+                '- Another format → equivalent Norn syntax',
+                'Produce valid .norn output. Preserve headers, body, and method. Wrap in ```norn code fences.',
+                '',
+                `User input: ${prompt}`,
+            ].join('\n');
+        default:
+            // General question — no extra framing needed, the system prompt is enough
+            return prompt;
+    }
+}
+function handleLlmError(err, stream) {
+    if (err instanceof vscode.LanguageModelError) {
+        console.error('Norn Chat: LLM error', err.message, err.code);
+        if (err.cause instanceof Error && err.cause.message.includes('off_topic')) {
+            stream.markdown('I can only help with **Norn REST client** questions — writing requests, sequences, assertions, environments, and CLI usage. Please ask something related to Norn.');
+        }
+        else {
+            stream.markdown(`Something went wrong communicating with the language model. Please try again.\n\n*Error: ${err.message}*`);
+        }
+    }
+    else {
+        throw err;
+    }
+}
+//# sourceMappingURL=chatParticipant.js.map