snow-flow 3.0.9 → 3.0.13

package/dist/utils/file-storage-fallback.d.ts

@@ -1,62 +0,0 @@
-/**
- * File Storage Fallback
- * WORKAROUND: Alternative to MCP memory_usage for storing large data
- * Uses local filesystem instead of unreliable MCP memory operations
- */
-export declare class FileStorageFallback {
-    private static readonly STORAGE_DIR;
-    /**
-     * Initialize file storage directory
-     */
-    static initialize(): Promise<void>;
-    /**
-     * Store data to file (replacement for memory_usage store)
-     */
-    static store(key: string, data: any): Promise<void>;
-    /**
-     * Retrieve data from file (replacement for memory_usage retrieve)
-     */
-    static retrieve(key: string): Promise<any>;
-    /**
-     * Delete stored data
-     */
-    static delete(key: string): Promise<void>;
-    /**
-     * List all stored keys
-     */
-    static list(pattern?: string): Promise<string[]>;
-    /**
-     * Clear all stored data
-     */
-    static clear(): Promise<void>;
-    /**
-     * Get storage statistics
-     */
-    static getStats(): Promise<{
-        totalFiles: number;
-        totalSizeKB: number;
-        largestFileKB: number;
-        oldestFileAge: number;
-    }>;
-    /**
-     * Get file path for a given key
-     */
-    private static getFilePath;
-    /**
-     * WORKAROUND: Direct replacement for MCP memory_usage
-     * Provides drop-in replacement with same interface
-     */
-    static mcpMemoryReplacement(action: string, key?: string, value?: any): Promise<any>;
-}
-export declare const fileStore: (key: string, value: any) => Promise<void>;
-export declare const fileRetrieve: (key: string) => Promise<any>;
-export declare const fileDelete: (key: string) => Promise<void>;
-export declare const fileList: (pattern?: string) => Promise<string[]>;
-export declare const fileClear: () => Promise<void>;
-export declare const fileStats: () => Promise<{
-    totalFiles: number;
-    totalSizeKB: number;
-    largestFileKB: number;
-    oldestFileAge: number;
-}>;
-//# sourceMappingURL=file-storage-fallback.d.ts.map

package/dist/utils/file-storage-fallback.js

@@ -1,289 +0,0 @@
-"use strict";
-/**
- * File Storage Fallback
- * WORKAROUND: Alternative to MCP memory_usage for storing large data
- * Uses local filesystem instead of unreliable MCP memory operations
- */
-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.fileStats = exports.fileClear = exports.fileList = exports.fileDelete = exports.fileRetrieve = exports.fileStore = exports.FileStorageFallback = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const logger_js_1 = require("./logger.js");
-const logger = new logger_js_1.Logger('FileStorageFallback');
-class FileStorageFallback {
-    /**
-     * Initialize file storage directory
-     */
-    static async initialize() {
-        try {
-            await fs.promises.mkdir(this.STORAGE_DIR, { recursive: true });
-            logger.info(`📁 File storage initialized at: ${this.STORAGE_DIR}`);
-        }
-        catch (error) {
-            logger.error('Failed to initialize file storage:', error);
-            throw error;
-        }
-    }
-    /**
-     * Store data to file (replacement for memory_usage store)
-     */
-    static async store(key, data) {
-        try {
-            const filePath = this.getFilePath(key);
-            const dirPath = path.dirname(filePath);
-            // Ensure directory exists
-            await fs.promises.mkdir(dirPath, { recursive: true });
-            // Store data as JSON
-            const jsonData = JSON.stringify(data, null, 2);
-            // Check size (warn if large)
-            const sizeKB = Buffer.byteLength(jsonData) / 1024;
-            if (sizeKB > 1024) {
-                logger.warn(`⚠️ Storing large data (${sizeKB.toFixed(2)} KB) to file: ${key}`);
-            }
-            await fs.promises.writeFile(filePath, jsonData, 'utf-8');
-            logger.debug(`✅ Stored data to file: ${key}`);
-        }
-        catch (error) {
-            logger.error(`Failed to store data for key '${key}':`, error);
-            throw new Error(`File storage failed: ${error.message}`);
-        }
-    }
-    /**
-     * Retrieve data from file (replacement for memory_usage retrieve)
-     */
-    static async retrieve(key) {
-        try {
-            const filePath = this.getFilePath(key);
-            // Check if file exists
-            if (!fs.existsSync(filePath)) {
-                logger.debug(`No data found for key: ${key}`);
-                return null;
-            }
-            // Read and parse data
-            const jsonData = await fs.promises.readFile(filePath, 'utf-8');
-            const data = JSON.parse(jsonData);
-            logger.debug(`✅ Retrieved data from file: ${key}`);
-            return data;
-        }
-        catch (error) {
-            logger.error(`Failed to retrieve data for key '${key}':`, error);
-            // Return null instead of throwing to match memory_usage behavior
-            return null;
-        }
-    }
-    /**
-     * Delete stored data
-     */
-    static async delete(key) {
-        try {
-            const filePath = this.getFilePath(key);
-            if (fs.existsSync(filePath)) {
-                await fs.promises.unlink(filePath);
-                logger.debug(`🗑️ Deleted file: ${key}`);
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to delete data for key '${key}':`, error);
-        }
-    }
-    /**
-     * List all stored keys
-     */
-    static async list(pattern) {
-        try {
-            const keys = [];
-            const walkDir = async (dir, prefix = '') => {
-                try {
-                    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-                    for (const entry of entries) {
-                        const fullPath = path.join(dir, entry.name);
-                        const key = prefix ? `${prefix}/${entry.name}` : entry.name;
-                        if (entry.isDirectory()) {
-                            await walkDir(fullPath, key);
-                        }
-                        else if (entry.name.endsWith('.json')) {
-                            const keyName = key.replace(/\.json$/, '');
-                            // Apply pattern filter if provided
-                            if (!pattern || keyName.includes(pattern)) {
-                                keys.push(keyName);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.debug(`Error walking directory ${dir}:`, error.message);
-                }
-            };
-            await walkDir(this.STORAGE_DIR);
-            return keys;
-        }
-        catch (error) {
-            logger.error('Failed to list stored keys:', error);
-            return [];
-        }
-    }
-    /**
-     * Clear all stored data
-     */
-    static async clear() {
-        try {
-            // Remove and recreate the storage directory
-            if (fs.existsSync(this.STORAGE_DIR)) {
-                await fs.promises.rm(this.STORAGE_DIR, { recursive: true, force: true });
-            }
-            await fs.promises.mkdir(this.STORAGE_DIR, { recursive: true });
-            logger.info('🧹 Cleared all file storage');
-        }
-        catch (error) {
-            logger.error('Failed to clear file storage:', error);
-        }
-    }
-    /**
-     * Get storage statistics
-     */
-    static async getStats() {
-        try {
-            let totalFiles = 0;
-            let totalSize = 0;
-            let largestSize = 0;
-            let oldestTime = Date.now();
-            const walkDir = async (dir) => {
-                try {
-                    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-                    for (const entry of entries) {
-                        const fullPath = path.join(dir, entry.name);
-                        if (entry.isDirectory()) {
-                            await walkDir(fullPath);
-                        }
-                        else if (entry.name.endsWith('.json')) {
-                            totalFiles++;
-                            const stats = await fs.promises.stat(fullPath);
-                            totalSize += stats.size;
-                            largestSize = Math.max(largestSize, stats.size);
-                            oldestTime = Math.min(oldestTime, stats.mtimeMs);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.debug(`Error getting stats for ${dir}:`, error.message);
-                }
-            };
-            await walkDir(this.STORAGE_DIR);
-            return {
-                totalFiles,
-                totalSizeKB: totalSize / 1024,
-                largestFileKB: largestSize / 1024,
-                oldestFileAge: Date.now() - oldestTime
-            };
-        }
-        catch (error) {
-            logger.error('Failed to get storage stats:', error);
-            return {
-                totalFiles: 0,
-                totalSizeKB: 0,
-                largestFileKB: 0,
-                oldestFileAge: 0
-            };
-        }
-    }
-    /**
-     * Get file path for a given key
-     */
-    static getFilePath(key) {
-        // Sanitize key to create valid file path
-        const sanitizedKey = key
-            .replace(/[^a-zA-Z0-9_\-\/]/g, '_')
-            .replace(/\/+/g, '/')
-            .replace(/^\/|\/$/g, '');
-        return path.join(this.STORAGE_DIR, `${sanitizedKey}.json`);
-    }
-    /**
-     * WORKAROUND: Direct replacement for MCP memory_usage
-     * Provides drop-in replacement with same interface
-     */
-    static async mcpMemoryReplacement(action, key, value) {
-        logger.info(`📁 Using file storage fallback for MCP memory operation: ${action}`);
-        switch (action) {
-            case 'store':
-                if (!key)
-                    throw new Error('Key required for store operation');
-                await this.store(key, value);
-                return { success: true, message: 'Stored to file' };
-            case 'retrieve':
-                if (!key)
-                    throw new Error('Key required for retrieve operation');
-                const data = await this.retrieve(key);
-                return { success: true, data };
-            case 'delete':
-                if (!key)
-                    throw new Error('Key required for delete operation');
-                await this.delete(key);
-                return { success: true, message: 'Deleted from file' };
-            case 'list':
-                const keys = await this.list(key); // key used as pattern
-                return { success: true, keys };
-            case 'clear':
-                await this.clear();
-                return { success: true, message: 'Cleared all file storage' };
-            case 'stats':
-                const stats = await this.getStats();
-                return { success: true, stats };
-            default:
-                throw new Error(`Unknown action: ${action}`);
-        }
-    }
-}
-exports.FileStorageFallback = FileStorageFallback;
-FileStorageFallback.STORAGE_DIR = path.join(process.env.SNOW_FLOW_HOME || path.join(os.homedir(), '.snow-flow'), 'file-storage');
-// Auto-initialize on module load
-FileStorageFallback.initialize().catch(error => {
-    logger.error('Failed to auto-initialize file storage:', error);
-});
-// Export convenience functions for drop-in replacement
-const fileStore = (key, value) => FileStorageFallback.store(key, value);
-exports.fileStore = fileStore;
-const fileRetrieve = (key) => FileStorageFallback.retrieve(key);
-exports.fileRetrieve = fileRetrieve;
-const fileDelete = (key) => FileStorageFallback.delete(key);
-exports.fileDelete = fileDelete;
-const fileList = (pattern) => FileStorageFallback.list(pattern);
-exports.fileList = fileList;
-const fileClear = () => FileStorageFallback.clear();
-exports.fileClear = fileClear;
-const fileStats = () => FileStorageFallback.getStats();
-exports.fileStats = fileStats;
-//# sourceMappingURL=file-storage-fallback.js.map

package/dist/utils/flow-api-discovery.d.ts

@@ -1,151 +0,0 @@
-/**
- * ServiceNow Flow Designer API Discovery Service
- * Provides dynamic discovery of action types, trigger types, and flow metadata
- */
-import { ServiceNowClient } from './servicenow-client.js';
-import { ActionType, TriggerType } from './action-type-cache.js';
-export interface FlowActionType extends ActionType {
-    description?: string;
-    category: string;
-    inputs: FlowActionInput[];
-    outputs: FlowActionOutput[];
-    script_template?: string;
-    execution_mode?: string;
-    supports_async?: boolean;
-}
-export interface FlowActionInput {
-    sys_id: string;
-    name: string;
-    label: string;
-    type: string;
-    required: boolean;
-    default_value?: string;
-    description?: string;
-    validation?: string;
-}
-export interface FlowActionOutput {
-    sys_id: string;
-    name: string;
-    label: string;
-    type: string;
-    description?: string;
-    sample_value?: string;
-}
-export interface FlowTriggerType extends TriggerType {
-    description?: string;
-    supports_conditions: boolean;
-    supported_tables: string[];
-    inputs: FlowTriggerInput[];
-    outputs: FlowTriggerOutput[];
-}
-export interface FlowTriggerInput {
-    sys_id: string;
-    name: string;
-    label: string;
-    type: string;
-    required: boolean;
-    description?: string;
-}
-export interface FlowTriggerOutput {
-    sys_id: string;
-    name: string;
-    label: string;
-    type: string;
-    description?: string;
-}
-export interface ActionTypeSearchResult {
-    exact_matches: FlowActionType[];
-    partial_matches: FlowActionType[];
-    semantic_matches: FlowActionType[];
-    confidence_score: number;
-}
-export declare class FlowAPIDiscovery {
-    private logger;
-    private client;
-    private actionTypeCache;
-    private triggerTypeCache;
-    private cacheExpiry;
-    private lastCacheUpdate;
-    constructor(client: ServiceNowClient);
-    /**
-     * Discover action types based on natural language intent
-     */
-    discoverActionTypes(intent: string, limit?: number): Promise<ActionTypeSearchResult>;
-    /**
-     * Discover trigger types based on table and operation
-     */
-    discoverTriggerTypes(table: string, operation: string): Promise<FlowTriggerType[]>;
-    /**
-     * Get detailed action type information including inputs/outputs
-     */
-    getActionTypeDetails(actionTypeId: string): Promise<FlowActionType | null>;
-    /**
-     * Get all available action categories
-     */
-    getActionCategories(): Promise<string[]>;
-    /**
-     * Search for actions by category
-     */
-    getActionsByCategory(category: string, limit?: number): Promise<FlowActionType[]>;
-    /**
-     * Validate action input configuration
-     */
-    validateActionInputs(actionTypeId: string, inputs: Record<string, any>): Promise<{
-        valid: boolean;
-        errors: string[];
-        warnings: string[];
-    }>;
-    /**
-     * Suggest action types based on flow context
-     */
-    suggestActionTypes(flowContext: {
-        previousActions: string[];
-        targetTable: string;
-        flowPurpose: string;
-    }): Promise<FlowActionType[]>;
-    /**
-     * Ensure cache is up to date
-     */
-    private ensureCache;
-    /**
-     * Refresh cache from ServiceNow
-     */
-    private refreshCache;
-    /**
-     * Fetch action types from ServiceNow
-     */
-    private fetchActionTypes;
-    /**
-     * Fetch trigger types from ServiceNow
-     */
-    private fetchTriggerTypes;
-    /**
-     * Fetch inputs and outputs for an action type
-     */
-    private fetchActionTypeInputsOutputs;
-    /**
-     * Get semantic mappings for common intents
-     */
-    private getSemanticMappings;
-    /**
-     * Calculate confidence score for search results
-     */
-    private calculateConfidenceScore;
-    /**
-     * Extract context keywords from flow context
-     */
-    private extractContextKeywords;
-    /**
-     * Score category relevance
-     */
-    private scoreCategory;
-    /**
-     * Score description relevance
-     */
-    private scoreDescription;
-    /**
-     * Score compatibility with flow context
-     */
-    private scoreCompatibility;
-}
-//# sourceMappingURL=flow-api-discovery.d.ts.map