norn-cli 2.3.0 → 2.4.0

package/out/inlayHintResolver.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Shared resolver used by every Norn file type's inlay hint provider.
+ *
+ * The provider's job is to assemble the right scope (just env vars for .nornapi,
+ * env + file-locals + sequence-locals for .norn, etc.) and hand the resulting
+ * `variables` map to `resolveInlayValueLabel` for each `{{...}}` token it finds.
+ *
+ * Unresolvable references — response refs (`{{$1.body.id}}`), unknown names, cycles —
+ * return `undefined`. The provider then renders nothing inline (no `(runtime)` label).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInlayReference = parseInlayReference;
+exports.resolveInlayValueLabel = resolveInlayValueLabel;
+const environmentTemplates_1 = require("./environmentTemplates");
+const ENV_TOKEN_REGEX = /^\$env\.([a-zA-Z_][a-zA-Z0-9_]*)$/;
+const PLAIN_TOKEN_REGEX = /^([a-zA-Z_][a-zA-Z0-9_]*)(?:\.[a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])*$/;
+const RESPONSE_TOKEN_REGEX = /^\$\d+/;
+/**
+ * Parses a token like `name`, `$env.name`, `name.path.to.value`, or `$1.body.id`.
+ * Returns the bare root variable name (the part we can look up at edit time)
+ * or `undefined` for response refs / malformed tokens we can never resolve statically.
+ */
+function parseInlayReference(rawReference) {
+    const trimmed = rawReference.trim();
+    if (RESPONSE_TOKEN_REGEX.test(trimmed)) {
+        return undefined;
+    }
+    const envMatch = trimmed.match(ENV_TOKEN_REGEX);
+    if (envMatch) {
+        return { name: envMatch[1], envOnly: true };
+    }
+    const plainMatch = trimmed.match(PLAIN_TOKEN_REGEX);
+    if (plainMatch) {
+        return { name: plainMatch[1], envOnly: false };
+    }
+    return undefined;
+}
+const MAX_INLAY_LENGTH = 80;
+function truncateInlayValue(value) {
+    return value.length > MAX_INLAY_LENGTH ? `${value.slice(0, MAX_INLAY_LENGTH - 3)}...` : value;
+}
+/**
+ * Looks up a reference in `variables` and returns the label to render inline,
+ * or `undefined` to skip (unknown name, response ref, cycle, etc).
+ *
+ * `variables` should already be the fully-merged scope the caller wants resolved
+ * against — innermost wins. For example, in a `.norn` sequence the caller merges
+ * `env + file-locals + sequence-locals` before calling this.
+ */
+function resolveInlayValueLabel(rawReference, variables, secretNames) {
+    const parsed = parseInlayReference(rawReference);
+    if (!parsed) {
+        return undefined;
+    }
+    if (!Object.prototype.hasOwnProperty.call(variables, parsed.name)) {
+        return undefined;
+    }
+    const resolved = (0, environmentTemplates_1.resolveEnvironmentTemplateValue)(parsed.name, variables, secretNames);
+    if (resolved.errors.length > 0) {
+        return undefined;
+    }
+    const isSecret = resolved.secret || secretNames.has(parsed.name);
+    return {
+        label: isSecret ? '(secret)' : `"${truncateInlayValue(resolved.value)}"`,
+        secret: isSecret,
+        value: resolved.value
+    };
+}
+//# sourceMappingURL=inlayHintResolver.js.map

package/out/jsonFileReader.js

@@ -0,0 +1,323 @@
+"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.JsonVariableStore = void 0;
+exports.isJsonCommand = isJsonCommand;
+exports.parseJsonCommand = parseJsonCommand;
+exports.readJsonFile = readJsonFile;
+exports.getNestedValue = getNestedValue;
+exports.setNestedValue = setNestedValue;
+exports.isPropertyAssignment = isPropertyAssignment;
+exports.parsePropertyAssignment = parsePropertyAssignment;
+exports.valueToString = valueToString;
+exports.substituteVariablesWithJson = substituteVariablesWithJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pathAccess_1 = require("./pathAccess");
+/**
+ * Checks if a line is a JSON file command.
+ * Formats:
+ *   var name = run readJson ./path/to/file.json
+ *   var name = run readJson "/path with spaces/file.json"
+ */
+function isJsonCommand(line) {
+    const trimmed = line.trim();
+    return /^var\s+[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*run\s+readJson\s+/i.test(trimmed);
+}
+/**
+ * Parses a JSON file command line.
+ * Format: var <name> = run readJson <path>
+ */
+function parseJsonCommand(line) {
+    const trimmed = line.trim();
+    // Match: var varName = run readJson path
+    const match = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*run\s+readJson\s+(.+)$/i);
+    if (!match) {
+        return null;
+    }
+    let filePath = match[2].trim();
+    // Remove quotes if present
+    if ((filePath.startsWith('"') && filePath.endsWith('"')) ||
+        (filePath.startsWith("'") && filePath.endsWith("'"))) {
+        filePath = filePath.slice(1, -1);
+    }
+    return {
+        varName: match[1],
+        filePath
+    };
+}
+/**
+ * Reads and parses a JSON file.
+ */
+function readJsonFile(filePath, workingDir) {
+    // Resolve relative paths
+    const resolvedPath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(workingDir || process.cwd(), filePath);
+    try {
+        if (!fs.existsSync(resolvedPath)) {
+            return {
+                success: false,
+                error: `File not found: ${resolvedPath}`,
+                filePath: resolvedPath
+            };
+        }
+        const content = fs.readFileSync(resolvedPath, 'utf-8');
+        const data = JSON.parse(content);
+        return {
+            success: true,
+            data,
+            filePath: resolvedPath
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            error: `Failed to read/parse JSON file: ${message}`,
+            filePath: resolvedPath
+        };
+    }
+}
+/**
+ * Gets a value from an object using a dot-notation path.
+ * Supports array indexing with brackets: obj.array[0].property
+ *
+ * @param obj The source object
+ * @param path The dot-notation path (e.g., "user.addresses[0].city")
+ * @returns The value at the path, or undefined if not found
+ */
+function getNestedValue(obj, path) {
+    return (0, pathAccess_1.getNestedPathValue)(obj, path);
+}
+/**
+ * Sets a value in an object using a dot-notation path.
+ * Creates intermediate objects/arrays as needed.
+ * Supports array indexing with brackets: obj.array[0].property
+ *
+ * @param obj The source object to modify
+ * @param path The dot-notation path (e.g., "user.addresses[0].city")
+ * @param value The value to set
+ * @returns true if successful, false if the path is invalid
+ */
+function setNestedValue(obj, path, value) {
+    if (!path || obj === null || obj === undefined || typeof obj !== 'object') {
+        return false;
+    }
+    // Convert [0] to .0 and split by dots
+    const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(p => p !== '');
+    if (parts.length === 0) {
+        return false;
+    }
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const nextPart = parts[i + 1];
+        if (current[part] === undefined || current[part] === null) {
+            // Create intermediate object or array based on next part
+            current[part] = /^\d+$/.test(nextPart) ? [] : {};
+        }
+        current = current[part];
+        if (typeof current !== 'object') {
+            return false; // Can't navigate further
+        }
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = value;
+    return true;
+}
+/**
+ * Checks if a line is a property assignment command.
+ * Format: varName.property.path = value
+ *         varName[0].property = value
+ */
+function isPropertyAssignment(line) {
+    const trimmed = line.trim();
+    // Match: identifier followed by . or [ then = something
+    // But NOT starting with 'var ' or other keywords
+    return /^[a-zA-Z_][a-zA-Z0-9_]*[\.\[]/.test(trimmed) &&
+        /=/.test(trimmed) &&
+        !trimmed.startsWith('var ') &&
+        !trimmed.startsWith('run ') &&
+        !trimmed.startsWith('print ') &&
+        !trimmed.startsWith('assert ') &&
+        !trimmed.startsWith('sequence ');
+}
+/**
+ * Parses a property assignment command.
+ * Format: varName.path.to.property = value
+ * Returns the variable name, the property path, and the value.
+ */
+function parsePropertyAssignment(line) {
+    const trimmed = line.trim();
+    // Match: varName.path = value OR varName[0].path = value
+    const match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])+)\s*=\s*(.+)$/);
+    if (!match) {
+        return null;
+    }
+    const varName = match[1];
+    let propertyPath = match[2];
+    const value = match[3].trim();
+    // Remove leading dot if present
+    if (propertyPath.startsWith('.')) {
+        propertyPath = propertyPath.substring(1);
+    }
+    return {
+        varName,
+        propertyPath,
+        value
+    };
+}
+/**
+ * Converts a value to a string for use in variable substitution.
+ */
+function valueToString(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Storage for JSON objects loaded during sequence execution.
+ * Maps variable names to their parsed JSON data.
+ */
+class JsonVariableStore {
+    jsonObjects = new Map();
+    /**
+     * Stores a JSON object under the given variable name.
+     */
+    set(varName, data) {
+        this.jsonObjects.set(varName, data);
+    }
+    /**
+     * Gets the raw JSON object for a variable.
+     */
+    get(varName) {
+        return this.jsonObjects.get(varName);
+    }
+    /**
+     * Checks if a variable is a JSON object.
+     */
+    has(varName) {
+        return this.jsonObjects.has(varName);
+    }
+    /**
+     * Gets a nested value from a JSON variable.
+     * @param varName The variable name
+     * @param path Optional dot-notation path within the object
+     */
+    getValue(varName, path) {
+        const obj = this.jsonObjects.get(varName);
+        if (obj === undefined) {
+            return undefined;
+        }
+        if (!path) {
+            return obj;
+        }
+        return getNestedValue(obj, path);
+    }
+    /**
+     * Clears all stored JSON objects.
+     */
+    clear() {
+        this.jsonObjects.clear();
+    }
+    /**
+     * Gets all variable names that have JSON objects stored.
+     */
+    getVariableNames() {
+        return Array.from(this.jsonObjects.keys());
+    }
+}
+exports.JsonVariableStore = JsonVariableStore;
+/**
+ * Substitutes variables in text, with support for JSON object property access.
+ * Handles both simple variables {{varName}} and nested access {{varName.property.path}}
+ *
+ * @param text The text containing variable references
+ * @param variables Simple string variables (name -> value)
+ * @param jsonStore Optional JSON variable store for complex objects
+ */
+function substituteVariablesWithJson(text, variables, jsonStore) {
+    // Match {{varName}}, {{$env.name}}, or {{varName.path.to.property}}
+    return text.replace(/\{\{(\$env|[a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)\}\}/g, (match, varName, pathPart) => {
+        // First check if it's a JSON object with a path
+        if (jsonStore && jsonStore.has(varName)) {
+            const path = pathPart ? pathPart.replace(/^\./, '') : '';
+            const value = jsonStore.getValue(varName, path);
+            return valueToString(value);
+        }
+        if (pathPart && varName in variables && typeof variables[varName] === 'object' && variables[varName] !== null) {
+            const path = pathPart.replace(/^\./, '');
+            const value = getNestedValue(variables[varName], path);
+            return value === undefined && varName === '$env' ? match : valueToString(value);
+        }
+        // Check if there's a path and we have a simple variable that might be JSON
+        if (pathPart && varName in variables && typeof variables[varName] === 'string') {
+            // Try to parse the variable value as JSON
+            try {
+                const parsed = JSON.parse(variables[varName]);
+                const path = pathPart.replace(/^\./, '');
+                const value = getNestedValue(parsed, path);
+                if (value === undefined && varName === '$env') {
+                    return match;
+                }
+                return valueToString(value);
+            }
+            catch {
+                if (varName === '$env') {
+                    return match;
+                }
+                // Not JSON, fall through to simple substitution
+            }
+        }
+        // Simple variable substitution
+        if (varName in variables) {
+            if (varName === '$env') {
+                return match;
+            }
+            return variables[varName];
+        }
+        // Variable not found, return original
+        return match;
+    });
+}
+//# sourceMappingURL=jsonFileReader.js.map

package/out/mcpClient.js

@@ -0,0 +1,193 @@
+"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.McpSessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const mcpConfig_1 = require("./mcpConfig");
+const mcpToolIntellisenseCache_1 = require("./mcpToolIntellisenseCache");
+const schemaGenerator_1 = require("./schemaGenerator");
+class NornJsonSchemaValidator {
+    getValidator(schema) {
+        return (input) => {
+            const result = (0, schemaGenerator_1.validateAgainstSchemaObjectDetailed)(input, schema);
+            if (result.valid) {
+                return {
+                    valid: true,
+                    data: input,
+                    errorMessage: undefined
+                };
+            }
+            return {
+                valid: false,
+                data: undefined,
+                errorMessage: result.errorStrings?.join('; ') || 'Schema validation failed'
+            };
+        };
+    }
+}
+function getNornClientVersion() {
+    try {
+        const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const NORN_CLIENT_VERSION = getNornClientVersion();
+function createClient() {
+    return new index_js_1.Client({ name: 'norn', version: NORN_CLIENT_VERSION }, {
+        capabilities: {},
+        jsonSchemaValidator: new NornJsonSchemaValidator()
+    });
+}
+function extractTextContent(content) {
+    return content
+        .filter(block => block.type === 'text' && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('\n');
+}
+function normalizeStructuredContent(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+class McpSessionManager {
+    sessions = new Map();
+    resolveSessionTarget(startPath, alias, envVariables) {
+        const { filePath, server } = (0, mcpConfig_1.resolveMcpServer)(startPath, alias, envVariables);
+        return {
+            sessionKey: `${filePath}::${alias.toLowerCase()}`,
+            server
+        };
+    }
+    async createSession(server, sessionKey) {
+        const client = createClient();
+        if (server.transport === 'stdio') {
+            const [command, ...args] = server.command;
+            const transport = new stdio_js_1.StdioClientTransport({
+                command,
+                args,
+                cwd: server.cwd
+            });
+            await client.connect(transport);
+        }
+        else {
+            const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(server.url), {
+                requestInit: server.headers ? { headers: server.headers } : undefined
+            });
+            await client.connect(transport, server.timeoutMs ? { timeout: server.timeoutMs } : undefined);
+        }
+        const session = {
+            client,
+            config: server,
+            toolsByName: new Map()
+        };
+        this.sessions.set(sessionKey, session);
+        return session;
+    }
+    async getSession(startPath, alias, envVariables) {
+        const target = this.resolveSessionTarget(startPath, alias, envVariables);
+        const existing = this.sessions.get(target.sessionKey);
+        if (existing) {
+            return existing;
+        }
+        return this.createSession(target.server, target.sessionKey);
+    }
+    async listTools(startPath, alias, envVariables) {
+        const session = await this.getSession(startPath, alias, envVariables);
+        const tools = [];
+        let cursor;
+        do {
+            const response = await session.client.listTools(cursor ? { cursor } : undefined, session.config.transport === 'http' && session.config.timeoutMs
+                ? { timeout: session.config.timeoutMs }
+                : undefined);
+            for (const tool of response.tools) {
+                tools.push(tool);
+                session.toolsByName.set(tool.name.toLowerCase(), tool);
+            }
+            cursor = response.nextCursor;
+        } while (cursor);
+        const { filePath } = (0, mcpConfig_1.resolveMcpServer)(startPath, alias, envVariables);
+        (0, mcpToolIntellisenseCache_1.saveMcpToolsForAlias)(filePath, alias, tools);
+        return { tools };
+    }
+    async getToolDefinition(startPath, alias, toolName, envVariables) {
+        const session = await this.getSession(startPath, alias, envVariables);
+        const normalizedToolName = toolName.toLowerCase();
+        const cached = session.toolsByName.get(normalizedToolName);
+        if (cached) {
+            return cached;
+        }
+        const listed = await this.listTools(startPath, alias, envVariables);
+        const resolved = listed.tools.find(tool => tool.name.toLowerCase() === normalizedToolName);
+        if (!resolved) {
+            throw new Error(`Tool '${toolName}' was not found on MCP server '${alias}'.`);
+        }
+        return resolved;
+    }
+    async callTool(startPath, alias, toolName, args, envVariables) {
+        const session = await this.getSession(startPath, alias, envVariables);
+        await this.getToolDefinition(startPath, alias, toolName, envVariables);
+        const result = await session.client.callTool({
+            name: toolName,
+            arguments: args
+        }, undefined, session.config.transport === 'http' && session.config.timeoutMs
+            ? { timeout: session.config.timeoutMs }
+            : undefined);
+        const content = (result.content || []);
+        return {
+            content,
+            structuredContent: normalizeStructuredContent(result.structuredContent),
+            isError: Boolean(result.isError),
+            text: extractTextContent(content),
+            server: alias,
+            tool: toolName
+        };
+    }
+    async closeAll() {
+        const sessions = Array.from(this.sessions.values());
+        this.sessions.clear();
+        await Promise.allSettled(sessions.map(session => session.client.close()));
+    }
+}
+exports.McpSessionManager = McpSessionManager;
+//# sourceMappingURL=mcpClient.js.map