@lhi/n8m 0.1.0

package/dist/services/ai.service.js

@@ -0,0 +1,421 @@
+import OpenAI from 'openai';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+// Base URLs and default models for known providers
+const PROVIDER_PRESETS = {
+    openai: {
+        defaultModel: 'gpt-4o',
+    },
+    anthropic: {
+        baseURL: 'https://api.anthropic.com/v1',
+        defaultModel: 'claude-sonnet-4-6',
+    },
+    gemini: {
+        baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+        defaultModel: 'gemini-2.5-flash',
+    },
+};
+export class AIService {
+    static instance;
+    client;
+    model;
+    constructor() {
+        // Load persisted config from ~/.n8m/config.json as fallback for env vars
+        let fileConfig = {};
+        try {
+            const configFile = path.join(os.homedir(), '.n8m', 'config.json');
+            fileConfig = JSON.parse(fsSync.readFileSync(configFile, 'utf-8'));
+        }
+        catch {
+            // Config file doesn't exist yet — that's fine
+        }
+        let apiKey = process.env.AI_API_KEY || fileConfig['aiKey'];
+        let baseURL = process.env.AI_BASE_URL || fileConfig['aiBaseUrl'];
+        let provider = (process.env.AI_PROVIDER || fileConfig['aiProvider'])?.toLowerCase();
+        // Backward compat: GEMINI_API_KEY still works
+        if (!apiKey && process.env.GEMINI_API_KEY) {
+            apiKey = process.env.GEMINI_API_KEY;
+            if (!provider)
+                provider = 'gemini';
+        }
+        if (!apiKey) {
+            console.warn('⚠️  No AI key found. Run: n8m config --ai-key <your-key> --ai-provider openai');
+        }
+        const preset = provider ? PROVIDER_PRESETS[provider] : undefined;
+        // Apply preset base URL unless the user explicitly set one
+        if (preset?.baseURL && !baseURL) {
+            baseURL = preset.baseURL;
+        }
+        this.model = process.env.AI_MODEL || fileConfig['aiModel'] || preset?.defaultModel || 'gpt-4o';
+        this.client = new OpenAI({
+            apiKey: apiKey || 'no-key',
+            ...(baseURL ? { baseURL } : {}),
+            defaultHeaders: provider === 'anthropic'
+                ? { 'anthropic-version': '2023-06-01' }
+                : undefined,
+        });
+    }
+    static getInstance() {
+        if (!AIService.instance) {
+            AIService.instance = new AIService();
+        }
+        return AIService.instance;
+    }
+    /**
+     * Core generation method — works with any OpenAI-compatible API
+     */
+    async generateContent(prompt, options = {}) {
+        const model = options.model || this.model;
+        const maxRetries = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                if (process.stdout.isTTY) {
+                    process.stdout.write('   (AI Thinking...)\n');
+                }
+                const stream = await this.client.chat.completions.create({
+                    model,
+                    messages: [{ role: 'user', content: prompt }],
+                    temperature: options.temperature ?? 0.7,
+                    stream: true,
+                });
+                let text = '';
+                for await (const chunk of stream) {
+                    text += chunk.choices[0]?.delta?.content || '';
+                }
+                return text;
+            }
+            catch (error) {
+                if (process.stdout.isTTY)
+                    process.stdout.write('\n');
+                lastError = error;
+                const isRetryable = error.status === 503 ||
+                    error.status === 529 ||
+                    (error.message && (error.message.includes('fetch failed') ||
+                        error.message.includes('ECONNRESET') ||
+                        error.message.includes('timeout')));
+                if (attempt < maxRetries && isRetryable) {
+                    const delay = Math.pow(2, attempt) * 1000;
+                    console.warn(`[AIService] Attempt ${attempt}/${maxRetries} failed: ${error.message}. Retrying in ${delay / 1000}s...`);
+                    await new Promise(r => setTimeout(r, delay));
+                    continue;
+                }
+                break;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Generate an n8n workflow from a description
+     */
+    async generateWorkflow(description) {
+        const systemPrompt = `You are an expert n8n workflow architect.
+    Your task is to generate a valid n8n workflow JSON based on the user's description.
+
+    Output ONLY valid JSON. No markdown formatting, no explanations.
+    The JSON must follow the n8n workflow schema with 'nodes' and 'connections' arrays.
+
+    User Description: ${description}`;
+        const response = await this.generateContent(systemPrompt);
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(cleanJson);
+        }
+        catch (e) {
+            console.error('Failed to parse generated workflow JSON', e);
+            throw new Error('AI generated invalid JSON');
+        }
+    }
+    /**
+     * Generate a Workflow Specification from a description
+     */
+    async generateSpec(description) {
+        const prompt = `You are an n8n Solutions Architect.
+    Convert the following user request into a structured Workflow Specification.
+
+    The Specification should be a JSON object with:
+    1. goal: A clear statement of the objective.
+    2. suggestedName: A concise, descriptive name for the main workflow (e.g., "Hourly Bitcoin Price Alert").
+    3. tasks: A list of strings, each describing a logical step to achieve the goal.
+    4. nodes: Potential n8n nodes involved (e.g. ['Webhook', 'HTTP Request', 'Slack']).
+    5. assumptions: Any assumptions made about credentials or environment.
+    6. questions: A list of string questions if the request is ambiguous or missing critical details. Empty if clear.
+
+    Output ONLY valid JSON.
+
+    User Request: ${description}`;
+        const response = await this.generateContent(prompt);
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(cleanJson);
+        }
+        catch (e) {
+            console.error('Failed to parse generated spec JSON', e);
+            throw new Error('AI generated invalid JSON for spec');
+        }
+    }
+    /**
+     * Refine a Specification based on user feedback
+     */
+    async refineSpec(spec, feedback) {
+        const prompt = `You are an n8n Solutions Architect.
+    Update the following Workflow Specification based on the user's feedback/answers.
+
+    Current Specification:
+    ${JSON.stringify(spec, null, 2)}
+
+    User Feedback:
+    ${feedback}
+
+    Ensure 'questions' is empty if the feedback resolves the ambiguity.
+    Output the UPDATED JSON Specification only.`;
+        const response = await this.generateContent(prompt);
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(cleanJson);
+        }
+        catch (e) {
+            console.error('Failed to parse refined spec JSON', e);
+            throw new Error('AI generated invalid JSON for refined spec');
+        }
+    }
+    /**
+     * Generate workflow JSONs from an approved Specification
+     */
+    async generateWorkflowFromSpec(spec) {
+        const prompt = `You are an n8n Workflow Engineer.
+      Generate the valid n8n workflow JSON(s) based on the following approved Specification.
+
+      Specification:
+      ${JSON.stringify(spec, null, 2)}
+
+      IMPORTANT:
+      1. Descriptive Naming: Name nodes descriptively (e.g. "Fetch Bitcoin Price" instead of "HTTP Request").
+      2. Multi-Workflow: If the spec requires multiple workflows (e.g. Main + Sub-workflow), generate them all.
+      3. Linking: If one workflow calls another (using an 'Execute Workflow' node), use the "suggestedName" of the target workflow as the 'workflowId' parameter value. Do NOT use generic IDs like "SUBWORKFLOW_ID".
+      4. Consistency: Ensure the "name" field in each workflow matches one of the suggestedNames from the spec.
+      5. Standard Node Types: Use valid n8n-nodes-base types.
+         - Use "n8n-nodes-base.rssFeedRead" for RSS reading (NOT "rssFeed").
+         - Use "n8n-nodes-base.httpRequest" for API calls.
+         - Use "n8n-nodes-base.openAi" for OpenAI.
+         - Use "n8n-nodes-base.googleGemini" for Google Gemini.
+         - Use "n8n-nodes-base.htmlExtract" for HTML/Cheerio extraction.
+      6. Connections Structure: The "connections" object keys MUST BE THE SOURCE NODE NAME. The "node" field inside the connection array MUST BE THE TARGET NODE NAME.
+      7. Connection Nesting: Ensure the correct n8n connection structure: "SourceNodeName": { "main": [ [ { "node": "TargetNodeName", "type": "main", "index": 0 } ] ] }.
+
+      Output a JSON object with this structure:
+      {
+         "workflows": [
+             { "name": "Workflow Name", "nodes": [...], "connections": {...} }
+         ]
+      }
+
+      Output ONLY valid JSON. No commentary. No markdown.
+      `;
+        const response = await this.generateContent(prompt);
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            const result = JSON.parse(cleanJson);
+            if (result.workflows && Array.isArray(result.workflows)) {
+                result.workflows = result.workflows.map((wf) => this.fixHallucinatedNodes(wf));
+            }
+            return result;
+        }
+        catch (e) {
+            console.error('Failed to parse workflow JSON from spec', e);
+            throw new Error('AI generated invalid JSON for workflow from spec');
+        }
+    }
+    /**
+     * Generate mock data for a workflow execution
+     */
+    async generateMockData(context, previousFailures = []) {
+        let failureContext = '';
+        if (previousFailures.length > 0) {
+            failureContext = `\n\nIMPORTANT: The following attempts FAILED. Do NOT repeat these patterns.\nErrors:\n${previousFailures.join('\n')}`;
+        }
+        const systemPrompt = `You are a QA Data Generator.
+    Your task is to generate a realistic JSON payload to trigger an n8n workflow.
+
+    CRITICAL: Output ONLY valid raw JSON. No markdown, no explanations, no "Okay" or "Here is".
+    If you include any text outside the JSON, the system will crash.
+
+    Context: ${context}${failureContext}`;
+        const response = await this.generateContent(systemPrompt);
+        let cleanJson = response || '{}';
+        cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+        try {
+            return JSON.parse(cleanJson);
+        }
+        catch (e) {
+            console.error('Failed to parse generated mock data', e);
+            return { message: 'AI generation failed, fallback data' };
+        }
+    }
+    /**
+     * Diagnostic Repair: Fix a workflow based on execution error
+     */
+    async generateWorkflowFix(workflowJson, errorContext, model, _useSearch = false, validNodeTypes = []) {
+        const prompt = `You are a Senior n8n Workflow Engineer.
+      A workflow failed during execution. Your task is to analyze the JSON and the Error, and provide a FIXED version of the workflow JSON.
+
+      Error Context:
+      ${errorContext}
+
+      Workflow JSON:
+      ${JSON.stringify(workflowJson, null, 2)}
+
+      Review the nodes involved in the error.
+      ${validNodeTypes.length > 0 ? `CRITICAL: You MUST only use node types from the following ALLOWED list: ${JSON.stringify(validNodeTypes.slice(0, 100))}... (and other standard n8n-nodes-base.* types). If a node type is not valid, replace it with 'n8n-nodes-base.httpRequest' or 'n8n-nodes-base.set'.` : ''}
+      IMPORTANT: If the error is "Unrecognized node type: n8n-nodes-base.schedule", you MUST fix it to "n8n-nodes-base.scheduleTrigger".
+      If a node produced 0 items, check its input data mapping or filter conditions.
+      If a node crashed, check missing parameters.
+
+      Output ONLY valid JSON. No markdown. RETURN THE ENTIRE FIXED WORKFLOW JSON.
+      `;
+        const response = await this.generateContent(prompt, { model });
+        try {
+            let cleanJson = response || '{}';
+            cleanJson = cleanJson.replace(/```json\n?|\n?```/g, '').trim();
+            const fixed = JSON.parse(cleanJson);
+            const invalidNodeMatch = errorContext.match(/Unrecognized node type: ([\w.-]+)/);
+            const explicitlyInvalid = invalidNodeMatch ? [invalidNodeMatch[1]] : [];
+            const corrected = this.fixHallucinatedNodes(fixed);
+            return this.validateAndShim(corrected, validNodeTypes, explicitlyInvalid);
+        }
+        catch (e) {
+            console.error('Failed to parse AI workflow fix', e);
+            throw new Error('AI generated invalid JSON for fix');
+        }
+    }
+    /**
+     * Auto-correct common n8n node type hallucinations
+     */
+    fixHallucinatedNodes(workflow) {
+        if (!workflow.nodes || !Array.isArray(workflow.nodes))
+            return workflow;
+        const corrections = {
+            'n8n-nodes-base.rssFeed': 'n8n-nodes-base.rssFeedRead',
+            'rssFeed': 'n8n-nodes-base.rssFeedRead',
+            'n8n-nodes-base.gpt': 'n8n-nodes-base.openAi',
+            'n8n-nodes-base.openai': 'n8n-nodes-base.openAi',
+            'openai': 'n8n-nodes-base.openAi',
+            'n8n-nodes-base.openAiChat': 'n8n-nodes-base.openAi',
+            'n8n-nodes-base.openAIChat': 'n8n-nodes-base.openAi',
+            'n8n-nodes-base.openaiChat': 'n8n-nodes-base.openAi',
+            'n8n-nodes-base.gemini': 'n8n-nodes-base.googleGemini',
+            'n8n-nodes-base.cheerioHtml': 'n8n-nodes-base.htmlExtract',
+            'cheerioHtml': 'n8n-nodes-base.htmlExtract',
+            'n8n-nodes-base.schedule': 'n8n-nodes-base.scheduleTrigger',
+            'schedule': 'n8n-nodes-base.scheduleTrigger',
+            'n8n-nodes-base.cron': 'n8n-nodes-base.scheduleTrigger',
+            'n8n-nodes-base.googleCustomSearch': 'n8n-nodes-base.googleGemini',
+            'googleCustomSearch': 'n8n-nodes-base.googleGemini',
+        };
+        workflow.nodes = workflow.nodes.map((node) => {
+            if (node.type && corrections[node.type]) {
+                console.log(`[AI Fix] Correcting node type: ${node.type} -> ${corrections[node.type]}`);
+                node.type = corrections[node.type];
+            }
+            if (node.type && !node.type.startsWith('n8n-nodes-base.') && !node.type.includes('.')) {
+                node.type = `n8n-nodes-base.${node.type}`;
+            }
+            return node;
+        });
+        return this.fixN8nConnections(workflow);
+    }
+    /**
+     * Force-fix connection structure to prevent "object is not iterable" errors
+     */
+    fixN8nConnections(workflow) {
+        if (!workflow.connections || typeof workflow.connections !== 'object')
+            return workflow;
+        const fixedConnections = {};
+        for (const [sourceNode, targets] of Object.entries(workflow.connections)) {
+            if (!targets || typeof targets !== 'object')
+                continue;
+            const targetObj = targets;
+            if (targetObj.main) {
+                let mainArr = targetObj.main;
+                if (!Array.isArray(mainArr))
+                    mainArr = [[{ node: String(mainArr), type: 'main', index: 0 }]];
+                const fixedMain = mainArr.map((segment) => {
+                    if (!segment)
+                        return [];
+                    if (!Array.isArray(segment))
+                        return [segment];
+                    return segment.map((conn) => {
+                        if (!conn)
+                            return { node: 'Unknown', type: 'main', index: 0 };
+                        if (typeof conn === 'string')
+                            return { node: conn, type: 'main', index: 0 };
+                        return {
+                            node: String(conn.node || 'Unknown'),
+                            type: conn.type || 'main',
+                            index: conn.index || 0,
+                        };
+                    });
+                });
+                fixedConnections[sourceNode] = { main: fixedMain };
+            }
+            else {
+                fixedConnections[sourceNode] = targetObj;
+            }
+        }
+        workflow.connections = fixedConnections;
+        return workflow;
+    }
+    /**
+     * Validate against real node types and shim unknown ones
+     */
+    validateAndShim(workflow, validNodeTypes = [], explicitlyInvalid = []) {
+        const valid = validNodeTypes || [];
+        const invalid = explicitlyInvalid || [];
+        if (valid.length === 0 && invalid.length === 0)
+            return workflow;
+        if (!workflow || !workflow.nodes || !Array.isArray(workflow.nodes))
+            return workflow;
+        const validSet = new Set(valid.map(t => t.toLowerCase()));
+        const invalidSet = new Set(invalid.map(t => t.toLowerCase()));
+        const isTrigger = (name) => name.toLowerCase().includes('trigger') || name.toLowerCase().includes('webhook');
+        workflow.nodes = workflow.nodes.map((node) => {
+            if (!node || !node.type)
+                return node;
+            const type = node.type.toLowerCase();
+            const shouldShim = invalidSet.has(type) || (validSet.size > 0 && !validSet.has(type));
+            if (!shouldShim)
+                return node;
+            console.warn(`[Validation] Unknown/Invalid node type detected: ${node.type}. Shimming...`);
+            const originalType = node.type;
+            const notes = `[Shim] Original Type: ${originalType}. Replaced because type is not installed on this n8n instance.`;
+            const apiKeywords = [
+                'api', 'http', 'slack', 'discord', 'telegram', 'google', 'aws',
+                'github', 'stripe', 'twilio', 'linear', 'notion', 'airtable',
+                'alpaca', 'openai', 'hubspot', 'mailchimp', 'postgres', 'mysql',
+                'redis', 'mongo', 'firebase', 'supabase',
+            ];
+            const isApi = apiKeywords.some(keyword => originalType.includes(keyword));
+            let replacementType = 'n8n-nodes-base.set';
+            if (isTrigger(originalType)) {
+                replacementType = 'n8n-nodes-base.webhook';
+            }
+            else if (isApi) {
+                replacementType = 'n8n-nodes-base.httpRequest';
+            }
+            return {
+                ...node,
+                type: replacementType,
+                typeVersion: 1,
+                notes,
+                credentials: {},
+                parameters: { options: {} },
+            };
+        });
+        return workflow;
+    }
+}

package/dist/services/n8n.service.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowExecutionResult } from '../utils/n8nClient.js';
+export declare class N8nService {
+    private static instance;
+    private baseUrl;
+    private apiKey;
+    private constructor();
+    static getInstance(): N8nService;
+    /**
+     * Deploy a workflow to n8n
+     */
+    deployWorkflow(workflow: any, activate?: boolean): Promise<any>;
+    private request;
+    /**
+     * Execute a workflow
+     */
+    executeWorkflow(workflowId: string): Promise<WorkflowExecutionResult>;
+}

package/dist/services/n8n.service.js

@@ -0,0 +1,81 @@
+export class N8nService {
+    static instance;
+    baseUrl;
+    apiKey;
+    constructor() {
+        this.baseUrl = process.env.N8N_API_URL || 'http://localhost:5678/api/v1';
+        this.apiKey = process.env.N8N_API_KEY || '';
+        if (!this.apiKey) {
+            console.warn('⚠️ N8N_API_KEY is not set. API calls will likely fail.');
+        }
+    }
+    static getInstance() {
+        if (!N8nService.instance) {
+            N8nService.instance = new N8nService();
+        }
+        return N8nService.instance;
+    }
+    /**
+     * Deploy a workflow to n8n
+     */
+    async deployWorkflow(workflow, activate = false) {
+        const payload = {
+            name: workflow.name || `My Workflow ${new Date().toISOString()}`,
+            nodes: workflow.nodes,
+            connections: workflow.connections,
+            settings: workflow.settings || {},
+        };
+        const response = await this.request('/workflows', {
+            method: 'POST',
+            body: JSON.stringify(payload)
+        });
+        if (activate && response.id) {
+            await this.request(`/workflows/${response.id}/activate`, { method: 'POST' });
+            response.active = true;
+        }
+        return response;
+    }
+    // Helper request method update
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'X-N8N-API-KEY': this.apiKey,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        try {
+            const response = await fetch(url, { ...options, headers });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                console.error(`n8n Error Body: ${errorBody}`);
+                throw new Error(`n8n API Error: ${response.status} ${response.statusText} - ${errorBody}`);
+            }
+            const text = await response.text();
+            return text ? JSON.parse(text) : {};
+        }
+        catch (error) {
+            console.error(`Request failed: ${url}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Execute a workflow
+     */
+    async executeWorkflow(workflowId) {
+        await this.request(`/workflows/${workflowId}/activate`, {
+            method: 'POST'
+        });
+        // Note: Actual execution trigger might depend on webhook or getting a test webhook URL
+        // For MVP, this might just toggle activation or assume it's a manual trigger
+        // Better: POST /workflows/:id/execute (if available in public API?)
+        // Public API actually supports `/workflows/:id/execute` in recent versions or via webhook
+        // Fallback Mock for now until we confirm endpoint availability or specific execution path
+        // Real implementation would POST to webhook or use executions API if supported
+        return {
+            executionId: 'mock-execution-' + Date.now(),
+            finished: true,
+            success: true,
+            data: { message: "Workflow executed (mock)" }
+        };
+    }
+}

package/dist/services/node-definitions.service.d.ts

@@ -0,0 +1,36 @@
+export interface ReducedNodeDefinition {
+    name: string;
+    displayName: string;
+    description: string;
+    properties: any[];
+}
+export declare class NodeDefinitionsService {
+    private static instance;
+    private definitions;
+    private client;
+    private constructor();
+    static getInstance(): NodeDefinitionsService;
+    /**
+     * Load definitions from n8n instance.
+     * In a real app, we might cache this to a file.
+     */
+    loadDefinitions(): Promise<void>;
+    /**
+     * Search for nodes relevant to the query.
+     * Simple keyword matching for now.
+     */
+    search(query: string, limit?: number): ReducedNodeDefinition[];
+    /**
+     * Get exact definitions for specific node types
+     */
+    getDefinitions(nodeNames: string[]): ReducedNodeDefinition[];
+    /**
+     * Compress the definition to save tokens.
+     * We keep properties (parameters) but strip UI metadata.
+     */
+    private reduceDefinition;
+    /**
+     * Format definitions for LLM System Prompt
+     */
+    formatForLLM(definitions: ReducedNodeDefinition[]): string;
+}

package/dist/services/node-definitions.service.js

@@ -0,0 +1,102 @@
+import { N8nClient } from '../utils/n8nClient.js';
+import { ConfigManager } from '../utils/config.js';
+export class NodeDefinitionsService {
+    static instance;
+    definitions = [];
+    client;
+    constructor() {
+        const n8nUrl = process.env.N8N_API_URL;
+        const n8nKey = process.env.N8N_API_KEY;
+        this.client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+    }
+    static getInstance() {
+        if (!NodeDefinitionsService.instance) {
+            NodeDefinitionsService.instance = new NodeDefinitionsService();
+        }
+        return NodeDefinitionsService.instance;
+    }
+    /**
+     * Load definitions from n8n instance.
+     * In a real app, we might cache this to a file.
+     */
+    async loadDefinitions() {
+        if (this.definitions.length > 0)
+            return;
+        console.log('Loading node definitions...');
+        try {
+            // Re-initialize client if env vars changed (e.g. after config load)
+            const config = await ConfigManager.load();
+            if (config.n8nUrl && config.n8nKey) {
+                this.client = new N8nClient({ apiUrl: config.n8nUrl, apiKey: config.n8nKey });
+            }
+            this.definitions = await this.client.getNodeTypes();
+            console.log(`Loaded ${this.definitions.length} node definitions.`);
+        }
+        catch (error) {
+            console.error("Failed to load node definitions:", error);
+            // Fallback to empty to allow process to continue without RAG
+            this.definitions = [];
+        }
+    }
+    /**
+     * Search for nodes relevant to the query.
+     * Simple keyword matching for now.
+     */
+    search(query, limit = 5) {
+        const lowerQuery = query.toLowerCase();
+        const terms = lowerQuery.split(/\s+/).filter(t => t.length > 2);
+        if (terms.length === 0)
+            return [];
+        const matches = this.definitions.filter(def => {
+            const text = `${def.displayName} ${def.name} ${def.description || ''}`.toLowerCase();
+            return terms.some(term => text.includes(term));
+        });
+        // Sort by relevance (number of matched terms) - simplified
+        return matches.slice(0, limit).map(this.reduceDefinition);
+    }
+    /**
+     * Get exact definitions for specific node types
+     */
+    getDefinitions(nodeNames) {
+        return this.definitions
+            .filter(def => nodeNames.includes(def.name))
+            .map(this.reduceDefinition);
+    }
+    /**
+     * Compress the definition to save tokens.
+     * We keep properties (parameters) but strip UI metadata.
+     */
+    reduceDefinition(def) {
+        return {
+            name: def.name,
+            displayName: def.displayName,
+            description: def.description,
+            // We need to carefully select properties. 
+            // n8n properties are complex. We want 'name', 'type', 'default', 'description', 'options'.
+            properties: (def.properties || []).map((p) => ({
+                name: p.name,
+                displayName: p.displayName,
+                type: p.type,
+                default: p.default,
+                description: p.description,
+                // For 'options' type (dropdowns), include options
+                options: p.options ? p.options.map((o) => ({ name: o.name, value: o.value })) : undefined,
+                // For 'collection' or 'fixedCollection', we need substructure. 
+                // This is a simplification. A full schema dump might be too large.
+                // Let's include 'typeOptions' as it often contains routing/validation info
+                typeOptions: p.typeOptions
+            }))
+        };
+    }
+    /**
+     * Format definitions for LLM System Prompt
+     */
+    formatForLLM(definitions) {
+        return definitions.map(def => `
+Node: ${def.displayName} (${def.name})
+Description: ${def.description}
+Parameters:
+${JSON.stringify(def.properties, null, 2)}
+`).join('\n---\n');
+    }
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,15 @@
+export interface N8mConfig {
+    n8nUrl?: string;
+    n8nKey?: string;
+    aiKey?: string;
+    aiProvider?: string;
+    aiModel?: string;
+    aiBaseUrl?: string;
+}
+export declare class ConfigManager {
+    private static configDir;
+    private static configFile;
+    static load(): Promise<N8mConfig>;
+    static save(config: Partial<N8mConfig>): Promise<void>;
+    static clear(): Promise<void>;
+}