@bridge_gpt/mcp-server 0.1.0

package/build/pipeline-utils.js

@@ -0,0 +1,175 @@
+/**
+ * Pipeline utilities — pure functions for schema validation, variable
+ * substitution, and recipe resolution.  Consumed by the build-time bundler
+ * (bundle-pipelines.js) and by MCP tool handlers at runtime.
+ */
+// ---------------------------------------------------------------------------
+// Schema Validation
+// ---------------------------------------------------------------------------
+export function validatePipelineSchema(json) {
+    const errors = [];
+    if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return { valid: false, errors: ["Pipeline must be a JSON object."] };
+    }
+    const obj = json;
+    // Top-level required fields
+    if (typeof obj.name !== "string" || obj.name.trim() === "") {
+        errors.push('Missing or empty required field "name" (string).');
+    }
+    if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+        errors.push('Missing or empty required field "steps" (non-empty array).');
+        return { valid: false, errors };
+    }
+    // Optional fields type checks
+    if (obj.description !== undefined && typeof obj.description !== "string") {
+        errors.push('"description" must be a string if provided.');
+    }
+    if (obj.variables !== undefined) {
+        if (!Array.isArray(obj.variables) ||
+            !obj.variables.every((v) => typeof v === "string")) {
+            errors.push('"variables" must be an array of strings if provided.');
+        }
+    }
+    // Step validation
+    const steps = obj.steps;
+    for (let i = 0; i < steps.length; i++) {
+        const prefix = `steps[${i}]`;
+        const step = steps[i];
+        if (typeof step !== "object" || step === null || Array.isArray(step)) {
+            errors.push(`${prefix}: must be an object.`);
+            continue;
+        }
+        const s = step;
+        if (typeof s.description !== "string" || s.description.trim() === "") {
+            errors.push(`${prefix}: missing or empty "description" (string).`);
+        }
+        if (s.on_error !== undefined) {
+            if (s.on_error !== "halt" && s.on_error !== "warn_and_continue") {
+                errors.push(`${prefix}: "on_error" must be "halt" or "warn_and_continue".`);
+            }
+        }
+        if (s.requires_approval !== undefined && typeof s.requires_approval !== "boolean") {
+            errors.push(`${prefix}: "requires_approval" must be a boolean if provided.`);
+        }
+        if (s.type === "mcp_call") {
+            if (typeof s.tool !== "string" || s.tool.trim() === "") {
+                errors.push(`${prefix}: mcp_call step requires "tool" (string).`);
+            }
+            if (typeof s.params !== "object" || s.params === null || Array.isArray(s.params)) {
+                errors.push(`${prefix}: mcp_call step requires "params" (object).`);
+            }
+        }
+        else if (s.type === "agent_task") {
+            const hasInstruction = typeof s.instruction === "string" && s.instruction.trim() !== "";
+            const hasInstructionFile = typeof s.instruction_file === "string" &&
+                s.instruction_file.trim() !== "";
+            if (hasInstruction && hasInstructionFile) {
+                errors.push(`${prefix}: agent_task must have exactly one of "instruction" or "instruction_file", not both.`);
+            }
+            else if (!hasInstruction && !hasInstructionFile) {
+                errors.push(`${prefix}: agent_task must have exactly one of "instruction" or "instruction_file".`);
+            }
+        }
+        else {
+            errors.push(`${prefix}: "type" must be "mcp_call" or "agent_task", got "${String(s.type)}".`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ---------------------------------------------------------------------------
+// Variable Handling
+// ---------------------------------------------------------------------------
+const variablePattern = () => /\{([a-zA-Z_][a-zA-Z0-9_]*)}/g;
+export function extractVariableReferences(text) {
+    const refs = [];
+    let match;
+    const pattern = variablePattern();
+    while ((match = pattern.exec(text)) !== null) {
+        if (!refs.includes(match[1])) {
+            refs.push(match[1]);
+        }
+    }
+    return refs;
+}
+export function substituteVariables(template, variables) {
+    return template.replace(variablePattern(), (full, name) => {
+        if (name in variables) {
+            return variables[name];
+        }
+        return full; // leave unresolved tokens as-is (build validates completeness)
+    });
+}
+function substituteDeep(value, variables) {
+    if (typeof value === "string") {
+        return substituteVariables(value, variables);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => substituteDeep(item, variables));
+    }
+    if (typeof value === "object" && value !== null) {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = substituteDeep(v, variables);
+        }
+        return result;
+    }
+    return value;
+}
+function substituteInParams(params, variables) {
+    return substituteDeep(params, variables);
+}
+// ---------------------------------------------------------------------------
+// Recipe Resolution
+// ---------------------------------------------------------------------------
+export function resolveRecipe(pipeline, instructions, variables, skipSteps) {
+    // Validate required variables are provided
+    const declared = pipeline.variables ?? [];
+    const missing = declared.filter((v) => !(v in variables));
+    if (missing.length > 0) {
+        throw new Error(`Missing required variable(s): ${missing.join(", ")}. ` +
+            `Pipeline "${pipeline.name}" declares: [${declared.join(", ")}].`);
+    }
+    const skip = new Set(skipSteps ?? []);
+    // Filter and resolve steps
+    const resolvedSteps = [];
+    let stepIndex = 1;
+    for (const step of pipeline.steps) {
+        // Determine skip key: tool name for mcp_call, description for agent_task
+        const skipKey = step.type === "mcp_call" ? step.tool : step.description;
+        if (skip.has(skipKey))
+            continue;
+        const base = {
+            step: stepIndex++,
+            type: step.type,
+            description: step.description,
+            on_error: step.on_error ?? "halt",
+            requires_approval: step.requires_approval ?? false,
+        };
+        if (step.type === "mcp_call") {
+            base.tool = step.tool;
+            base.params = substituteInParams(step.params, variables);
+        }
+        else {
+            // agent_task — resolve instruction
+            let rawInstruction;
+            if (step.instruction_file) {
+                const content = instructions[step.instruction_file];
+                if (content === undefined) {
+                    throw new Error(`Instruction file "${step.instruction_file}" not found in bundled instructions.`);
+                }
+                rawInstruction = content;
+            }
+            else {
+                rawInstruction = step.instruction;
+            }
+            base.instruction = substituteVariables(rawInstruction, variables);
+        }
+        resolvedSteps.push(base);
+    }
+    return {
+        pipeline: pipeline.name,
+        description: pipeline.description ?? "",
+        total_steps: resolvedSteps.length,
+        steps: resolvedSteps,
+    };
+}