@pagelines/n8n-mcp 0.3.1 → 0.3.2

package/src/autofix.ts

@@ -1,275 +0,0 @@
-/**
- * Auto-fix common n8n workflow issues
- * Transforms workflows to follow best practices
- */
-
-import type { N8nWorkflow, N8nNode, ValidationWarning } from './types.js';
-
-export interface AutofixResult {
-  workflow: N8nWorkflow;
-  fixes: AutofixAction[];
-  unfixable: ValidationWarning[];
-}
-
-export interface AutofixAction {
-  type: string;
-  target: string;
-  description: string;
-  before?: string;
-  after?: string;
-}
-
-/**
- * Auto-fix a workflow based on validation warnings
- */
-export function autofixWorkflow(
-  workflow: N8nWorkflow,
-  warnings: ValidationWarning[]
-): AutofixResult {
-  // Deep clone to avoid mutation
-  const fixed: N8nWorkflow = JSON.parse(JSON.stringify(workflow));
-  const fixes: AutofixAction[] = [];
-  const unfixable: ValidationWarning[] = [];
-
-  for (const warning of warnings) {
-    const result = attemptFix(fixed, warning);
-    if (result) {
-      fixes.push(result);
-    } else {
-      unfixable.push(warning);
-    }
-  }
-
-  return { workflow: fixed, fixes, unfixable };
-}
-
-function attemptFix(workflow: N8nWorkflow, warning: ValidationWarning): AutofixAction | null {
-  switch (warning.rule) {
-    case 'snake_case':
-      return fixSnakeCase(workflow, warning);
-
-    case 'explicit_reference':
-      return fixExplicitReference(workflow, warning);
-
-    case 'ai_structured_output':
-      return fixAIStructuredOutput(workflow, warning);
-
-    default:
-      // Rules that can't be auto-fixed:
-      // - no_hardcoded_secrets (need manual review)
-      // - no_hardcoded_ids (need manual review)
-      // - orphan_node (need context to know what to connect)
-      // - code_node_usage (info only)
-      // - in_memory_storage (architectural decision)
-      return null;
-  }
-}
-
-/**
- * Fix snake_case naming
- */
-function fixSnakeCase(workflow: N8nWorkflow, warning: ValidationWarning): AutofixAction | null {
-  const target = warning.node || 'workflow';
-
-  if (!warning.node) {
-    // Fix workflow name
-    const oldName = workflow.name;
-    const newName = toSnakeCase(oldName);
-
-    if (oldName === newName) return null;
-
-    workflow.name = newName;
-    return {
-      type: 'rename',
-      target: 'workflow',
-      description: `Renamed workflow to snake_case`,
-      before: oldName,
-      after: newName,
-    };
-  }
-
-  // Fix node name
-  const node = workflow.nodes.find((n) => n.name === warning.node);
-  if (!node) return null;
-
-  const oldName = node.name;
-  const newName = toSnakeCase(oldName);
-
-  if (oldName === newName) return null;
-
-  // Update node name
-  node.name = newName;
-
-  // Update connections that reference this node
-  if (workflow.connections[oldName]) {
-    workflow.connections[newName] = workflow.connections[oldName];
-    delete workflow.connections[oldName];
-  }
-
-  // Update connections that target this node
-  for (const outputs of Object.values(workflow.connections)) {
-    for (const outputType of Object.values(outputs)) {
-      for (const connections of outputType) {
-        for (const conn of connections) {
-          if (conn.node === oldName) {
-            conn.node = newName;
-          }
-        }
-      }
-    }
-  }
-
-  return {
-    type: 'rename',
-    target: `node:${oldName}`,
-    description: `Renamed node to snake_case`,
-    before: oldName,
-    after: newName,
-  };
-}
-
-/**
- * Convert to snake_case
- */
-function toSnakeCase(name: string): string {
-  return name
-    .replace(/([A-Z])/g, '_$1')
-    .replace(/[-\s]+/g, '_')
-    .replace(/^_/, '')
-    .replace(/_+/g, '_')
-    .toLowerCase();
-}
-
-/**
- * Fix $json to explicit references
- * This is a best-effort fix - may need manual review
- */
-function fixExplicitReference(
-  workflow: N8nWorkflow,
-  warning: ValidationWarning
-): AutofixAction | null {
-  if (!warning.node) return null;
-
-  const node = workflow.nodes.find((n) => n.name === warning.node);
-  if (!node) return null;
-
-  // Find the previous node in the connection chain
-  const previousNode = findPreviousNode(workflow, node.name);
-  if (!previousNode) {
-    // Can't auto-fix without knowing the source
-    return null;
-  }
-
-  // Replace $json with explicit reference
-  const params = JSON.stringify(node.parameters);
-  const fixedParams = params
-    .replace(/\$json\./g, `$('${previousNode}').item.json.`)
-    .replace(/\{\{\s*\$json\./g, `{{ $('${previousNode}').item.json.`);
-
-  if (params === fixedParams) return null;
-
-  node.parameters = JSON.parse(fixedParams);
-
-  return {
-    type: 'expression_fix',
-    target: `node:${node.name}`,
-    description: `Changed $json to explicit $('${previousNode}') reference`,
-    before: '$json.',
-    after: `$('${previousNode}').item.json.`,
-  };
-}
-
-/**
- * Find the previous node in the connection chain
- */
-function findPreviousNode(workflow: N8nWorkflow, nodeName: string): string | null {
-  for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
-    for (const outputType of Object.values(outputs)) {
-      for (const connections of outputType) {
-        for (const conn of connections) {
-          if (conn.node === nodeName) {
-            return sourceName;
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Fix AI structured output settings
- */
-function fixAIStructuredOutput(
-  workflow: N8nWorkflow,
-  warning: ValidationWarning
-): AutofixAction | null {
-  if (!warning.node) return null;
-
-  const node = workflow.nodes.find((n) => n.name === warning.node);
-  if (!node) return null;
-
-  const params = node.parameters as Record<string, unknown>;
-  const changes: string[] = [];
-
-  if (params.promptType !== 'define') {
-    params.promptType = 'define';
-    changes.push('promptType: "define"');
-  }
-
-  if (params.hasOutputParser !== true) {
-    params.hasOutputParser = true;
-    changes.push('hasOutputParser: true');
-  }
-
-  if (changes.length === 0) return null;
-
-  return {
-    type: 'parameter_fix',
-    target: `node:${node.name}`,
-    description: `Added AI structured output settings: ${changes.join(', ')}`,
-  };
-}
-
-/**
- * Format a workflow for consistency
- * - Sorts nodes by position
- * - Normalizes connection format
- * - Removes empty/null values
- */
-export function formatWorkflow(workflow: N8nWorkflow): N8nWorkflow {
-  const formatted: N8nWorkflow = JSON.parse(JSON.stringify(workflow));
-
-  // Sort nodes by Y position, then X
-  formatted.nodes.sort((a, b) => {
-    const [ax, ay] = a.position;
-    const [bx, by] = b.position;
-    if (ay !== by) return ay - by;
-    return ax - bx;
-  });
-
-  // Clean up parameters - remove undefined/null
-  for (const node of formatted.nodes) {
-    node.parameters = cleanObject(node.parameters);
-  }
-
-  return formatted;
-}
-
-/**
- * Remove null/undefined values from object
- */
-function cleanObject(obj: Record<string, unknown>): Record<string, unknown> {
-  const cleaned: Record<string, unknown> = {};
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === undefined) continue;
-    if (typeof value === 'object' && !Array.isArray(value)) {
-      cleaned[key] = cleanObject(value as Record<string, unknown>);
-    } else {
-      cleaned[key] = value;
-    }
-  }
-
-  return cleaned;
-}

package/src/expressions.ts

@@ -1,254 +0,0 @@
-/**
- * n8n expression validation
- * Parses and validates expressions in workflow parameters
- */
-
-import type { N8nWorkflow, N8nNode, ValidationWarning } from './types.js';
-
-export interface ExpressionIssue {
-  node: string;
-  parameter: string;
-  expression: string;
-  issue: string;
-  severity: 'error' | 'warning' | 'info';
-  suggestion?: string;
-}
-
-/**
- * Validate all expressions in a workflow
- */
-export function validateExpressions(workflow: N8nWorkflow): ExpressionIssue[] {
-  const issues: ExpressionIssue[] = [];
-  const nodeNames = new Set(workflow.nodes.map((n) => n.name));
-
-  for (const node of workflow.nodes) {
-    const nodeIssues = validateNodeExpressions(node, nodeNames);
-    issues.push(...nodeIssues);
-  }
-
-  return issues;
-}
-
-/**
- * Validate expressions in a single node
- */
-function validateNodeExpressions(node: N8nNode, nodeNames: Set<string>): ExpressionIssue[] {
-  const issues: ExpressionIssue[] = [];
-  const expressions = extractExpressions(node.parameters);
-
-  for (const { path, expression } of expressions) {
-    const exprIssues = validateExpression(expression, nodeNames);
-    for (const issue of exprIssues) {
-      issues.push({
-        node: node.name,
-        parameter: path,
-        expression,
-        ...issue,
-      });
-    }
-  }
-
-  return issues;
-}
-
-/**
- * Extract all expressions from parameters
- */
-function extractExpressions(
-  params: Record<string, unknown>,
-  basePath: string = ''
-): Array<{ path: string; expression: string }> {
-  const results: Array<{ path: string; expression: string }> = [];
-
-  for (const [key, value] of Object.entries(params)) {
-    const path = basePath ? `${basePath}.${key}` : key;
-
-    if (typeof value === 'string') {
-      // Check for expression patterns
-      const exprMatches = value.match(/\{\{.*?\}\}/g) || [];
-      for (const match of exprMatches) {
-        results.push({ path, expression: match });
-      }
-      // Also check for ={{ prefix (common in n8n)
-      if (value.startsWith('={{')) {
-        results.push({ path, expression: value });
-      }
-    } else if (typeof value === 'object' && value !== null) {
-      if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-          if (typeof value[i] === 'object' && value[i] !== null) {
-            results.push(...extractExpressions(value[i] as Record<string, unknown>, `${path}[${i}]`));
-          } else if (typeof value[i] === 'string') {
-            const strVal = value[i] as string;
-            const exprMatches = strVal.match(/\{\{.*?\}\}/g) || [];
-            for (const match of exprMatches) {
-              results.push({ path: `${path}[${i}]`, expression: match });
-            }
-          }
-        }
-      } else {
-        results.push(...extractExpressions(value as Record<string, unknown>, path));
-      }
-    }
-  }
-
-  return results;
-}
-
-/**
- * Validate a single expression
- */
-function validateExpression(
-  expression: string,
-  nodeNames: Set<string>
-): Array<Omit<ExpressionIssue, 'node' | 'parameter' | 'expression'>> {
-  const issues: Array<Omit<ExpressionIssue, 'node' | 'parameter' | 'expression'>> = [];
-
-  // Strip wrapper
-  let inner = expression;
-  if (inner.startsWith('={{')) {
-    inner = inner.slice(3).trim();
-  } else if (inner.startsWith('{{') && inner.endsWith('}}')) {
-    inner = inner.slice(2, -2).trim();
-  }
-
-  // Check for $json usage (should use explicit reference)
-  if (/\$json\./.test(inner) && !/\$\(['"]/.test(inner)) {
-    issues.push({
-      issue: 'Uses $json instead of explicit node reference',
-      severity: 'warning',
-      suggestion: "Use $('node_name').item.json.field instead",
-    });
-  }
-
-  // Check for $input usage (acceptable but check context)
-  if (/\$input\./.test(inner)) {
-    issues.push({
-      issue: '$input reference found - ensure this is intentional',
-      severity: 'info',
-      suggestion: "Consider explicit $('node_name') for clarity",
-    });
-  }
-
-  // Check for node references that don't exist
-  const nodeRefMatches = inner.matchAll(/\$\(['"]([^'"]+)['"]\)/g);
-  for (const match of nodeRefMatches) {
-    const refNodeName = match[1];
-    if (!nodeNames.has(refNodeName)) {
-      issues.push({
-        issue: `References non-existent node "${refNodeName}"`,
-        severity: 'error',
-        suggestion: `Check if the node exists or was renamed`,
-      });
-    }
-  }
-
-  // Check for common syntax errors
-  if (expression.includes('{{') && !expression.includes('}}')) {
-    issues.push({
-      issue: 'Missing closing }}',
-      severity: 'error',
-    });
-  }
-
-  // Check for unmatched parentheses
-  const openParens = (inner.match(/\(/g) || []).length;
-  const closeParens = (inner.match(/\)/g) || []).length;
-  if (openParens !== closeParens) {
-    issues.push({
-      issue: 'Unmatched parentheses',
-      severity: 'error',
-    });
-  }
-
-  // Check for unmatched brackets
-  const openBrackets = (inner.match(/\[/g) || []).length;
-  const closeBrackets = (inner.match(/\]/g) || []).length;
-  if (openBrackets !== closeBrackets) {
-    issues.push({
-      issue: 'Unmatched brackets',
-      severity: 'error',
-    });
-  }
-
-  // Check for deprecated patterns
-  if (/\$node\./.test(inner)) {
-    issues.push({
-      issue: '$node is deprecated',
-      severity: 'warning',
-      suggestion: "Use $('node_name') instead",
-    });
-  }
-
-  // Check for potential undefined access
-  if (/\.json\.[a-zA-Z_]+\.[a-zA-Z_]+/.test(inner) && !/\?\./g.test(inner)) {
-    issues.push({
-      issue: 'Deep property access without optional chaining',
-      severity: 'info',
-      suggestion: 'Consider using ?. for safer access: obj?.nested?.field',
-    });
-  }
-
-  return issues;
-}
-
-/**
- * Get all referenced nodes from expressions
- */
-export function getReferencedNodes(workflow: N8nWorkflow): Map<string, string[]> {
-  const references = new Map<string, string[]>();
-
-  for (const node of workflow.nodes) {
-    const expressions = extractExpressions(node.parameters);
-    const refsForNode: string[] = [];
-
-    for (const { expression } of expressions) {
-      const matches = expression.matchAll(/\$\(['"]([^'"]+)['"]\)/g);
-      for (const match of matches) {
-        const refName = match[1];
-        if (!refsForNode.includes(refName)) {
-          refsForNode.push(refName);
-        }
-      }
-    }
-
-    if (refsForNode.length > 0) {
-      references.set(node.name, refsForNode);
-    }
-  }
-
-  return references;
-}
-
-/**
- * Check for circular references in expressions
- */
-export function checkCircularReferences(workflow: N8nWorkflow): string[][] {
-  const references = getReferencedNodes(workflow);
-  const cycles: string[][] = [];
-
-  function findCycle(start: string, path: string[] = []): void {
-    if (path.includes(start)) {
-      const cycleStart = path.indexOf(start);
-      cycles.push([...path.slice(cycleStart), start]);
-      return;
-    }
-
-    const refs = references.get(start) || [];
-    for (const ref of refs) {
-      findCycle(ref, [...path, start]);
-    }
-  }
-
-  for (const nodeName of references.keys()) {
-    findCycle(nodeName);
-  }
-
-  // Deduplicate cycles
-  const uniqueCycles = cycles.filter((cycle, index) => {
-    const key = [...cycle].sort().join(',');
-    return cycles.findIndex((c) => [...c].sort().join(',') === key) === index;
-  });
-
-  return uniqueCycles;
-}