snow-flow 4.0.3 → 4.1.1

package/dist/llm/providers.d.ts

@@ -1,11 +0,0 @@
-import type { SnowFlowConfig } from '../config/llm-config-loader';
-export type ProviderId = SnowFlowConfig['llm']['provider'];
-export interface ProviderOptions {
-    provider: ProviderId;
-    model: string;
-    baseURL?: string;
-    apiKeyEnv?: string;
-    extraBody?: Record<string, unknown>;
-}
-export declare function getModel(opts: ProviderOptions): unknown;
-//# sourceMappingURL=providers.d.ts.map

package/dist/llm/providers.js

@@ -1,77 +0,0 @@
-"use strict";
-// Compile-safe placeholder registry. Real providers will be wired via AI SDK in a follow-up step.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModel = getModel;
-const keys_js_1 = require("./keys.js");
-function getModel(opts) {
-    const { provider, model, baseURL, apiKeyEnv, extraBody } = opts;
-    const requireOrThrow = (name) => {
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            return require(name);
-        }
-        catch (err) {
-            const hint = `Missing dependency ${name}. Run: npm i ai @ai-sdk/openai @ai-sdk/google @openrouter/ai-sdk-provider`;
-            throw new Error(hint);
-        }
-    };
-    switch (provider) {
-        case 'anthropic': {
-            // Prefer AI SDK anthropic provider if installed; otherwise instruct
-            try {
-                // Dynamic require to avoid hard dep
-                const anthropic = require('@ai-sdk/anthropic');
-                const key = process.env[apiKeyEnv || 'ANTHROPIC_API_KEY'] || (0, keys_js_1.getApiKey)('anthropic');
-                if (!key)
-                    throw new Error('Missing ANTHROPIC_API_KEY');
-                return anthropic.anthropic({ apiKey: key, baseURL }).languageModel(model);
-            }
-            catch (e) {
-                throw new Error('Anthropic provider not available. Install @ai-sdk/anthropic or use OpenRouter with an Anthropic model.');
-            }
-        }
-        case 'openai': {
-            const { openai } = requireOrThrow('@ai-sdk/openai');
-            const apiKey = process.env[apiKeyEnv || 'OPENAI_API_KEY'] || (0, keys_js_1.getApiKey)('openai');
-            if (!apiKey)
-                throw new Error('Missing OPENAI_API_KEY');
-            return openai({ apiKey, baseURL }).languageModel(model);
-        }
-        case 'google': {
-            const { google } = requireOrThrow('@ai-sdk/google');
-            const apiKey = process.env[apiKeyEnv || 'GOOGLE_API_KEY']
-                || process.env['GOOGLE_GENERATIVE_AI_API_KEY']
-                || (0, keys_js_1.getApiKey)('google');
-            if (!apiKey)
-                throw new Error('Missing GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY');
-            return google({ apiKey, baseURL }).languageModel(model);
-        }
-        case 'openrouter': {
-            const { createOpenRouter } = requireOrThrow('@openrouter/ai-sdk-provider');
-            const apiKey = process.env[apiKeyEnv || 'OPENROUTER_API_KEY'] || (0, keys_js_1.getApiKey)('openrouter');
-            if (!apiKey)
-                throw new Error('Missing OPENROUTER_API_KEY');
-            const or = createOpenRouter({ apiKey, baseURL, extraBody });
-            return or(model);
-        }
-        case 'openai-compatible': {
-            const { openai } = requireOrThrow('@ai-sdk/openai');
-            const keyName = apiKeyEnv || 'OPENAI_COMPAT_API_KEY';
-            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('openai-compatible');
-            if (!baseURL)
-                throw new Error('openai-compatible requires baseURL');
-            if (!apiKey)
-                throw new Error(`Missing ${keyName}`);
-            return openai({ apiKey, baseURL }).languageModel(model);
-        }
-        case 'ollama': {
-            const { openai } = requireOrThrow('@ai-sdk/openai');
-            const keyName = apiKeyEnv || 'OLLAMA_API_KEY';
-            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('ollama');
-            if (!baseURL)
-                throw new Error('ollama requires baseURL (e.g., http://localhost:11434/v1)');
-            return openai({ apiKey, baseURL }).languageModel(model);
-        }
-    }
-}
-//# sourceMappingURL=providers.js.map

package/dist/mcp/bridge.d.ts

@@ -1,10 +0,0 @@
-export interface MCPStartup {
-    cmd: string;
-    args?: string[];
-    env?: Record<string, string>;
-}
-export declare function loadMCPTools(start: MCPStartup): Promise<{
-    tools: any[];
-    close: () => Promise<void>;
-}>;
-//# sourceMappingURL=bridge.d.ts.map

package/dist/mcp/bridge.js

@@ -1,31 +0,0 @@
-"use strict";
-// Minimal MCP bridge placeholder. We will hook this into AI SDK tools in a next step.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadMCPTools = loadMCPTools;
-async function loadMCPTools(start) {
-    // Prefer using AI SDK's experimental MCP client to yield ready-to-use Tool[]
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { experimental_createMCPClient } = require('ai');
-        // Use SDK-provided stdio transport
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio');
-        const client = await experimental_createMCPClient({
-            name: 'snow-flow',
-            transport: new StdioClientTransport({
-                command: start.cmd,
-                args: start.args ?? [],
-                env: start.env ?? {},
-            }),
-        });
-        const tools = await client.tools();
-        return { tools, close: client.close };
-    }
-    catch (err) {
-        // Fallback: no AI SDK available, return empty tools and noop close but with a hint.
-        const hint = 'AI SDK MCP bridge not available. Install "ai" or verify version to enable MCP tools.';
-        console.warn(`[snow-flow] ${hint}`);
-        return { tools: [], close: async () => { } };
-    }
-}
-//# sourceMappingURL=bridge.js.map

package/dist/mcp/shared/mcp-types.d.ts

@@ -1,37 +0,0 @@
-/**
- * MCP Types
- * Common types for MCP server implementations
- */
-export interface MCPServerConfig {
-    name: string;
-    description?: string;
-    version?: string;
-}
-export interface MCPTool {
-    name: string;
-    description: string;
-    inputSchema: any;
-}
-export interface MCPResponse<T = any> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    message?: string;
-}
-export interface MCPRequest {
-    tool: string;
-    params: any;
-}
-export interface MCPLogger {
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, meta?: any): void;
-    debug(message: string, meta?: any): void;
-}
-export interface MCPMemoryManager {
-    store(key: string, value: any): Promise<void>;
-    retrieve(key: string): Promise<any>;
-    delete(key: string): Promise<boolean>;
-    list(): Promise<string[]>;
-}
-//# sourceMappingURL=mcp-types.d.ts.map

package/dist/mcp/shared/mcp-types.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * MCP Types
- * Common types for MCP server implementations
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=mcp-types.js.map

package/dist/memory/hierarchical-memory-system.d.ts

@@ -1,32 +0,0 @@
-/**
- * Hierarchical Memory System
- * Extended memory system with hierarchical organization
- */
-import { MemorySystem } from './memory-system';
-export interface HierarchicalMemorySystem extends MemorySystem {
-    dbPath?: string;
-    namespace?: string;
-    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
-    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
-    listNamespaces(): Promise<string[]>;
-    clearNamespace(namespace: string): Promise<void>;
-}
-export declare class DefaultHierarchicalMemorySystem implements HierarchicalMemorySystem {
-    private memory;
-    dbPath?: string;
-    namespace?: string;
-    constructor(dbPath?: string, namespace?: string);
-    private getNamespaceMap;
-    store(key: string, value: any): Promise<void>;
-    retrieve(key: string): Promise<any>;
-    get(key: string): Promise<any>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
-    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
-    listNamespaces(): Promise<string[]>;
-    clearNamespace(namespace: string): Promise<void>;
-}
-//# sourceMappingURL=hierarchical-memory-system.d.ts.map

package/dist/memory/hierarchical-memory-system.js

@@ -1,60 +0,0 @@
-"use strict";
-/**
- * Hierarchical Memory System
- * Extended memory system with hierarchical organization
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultHierarchicalMemorySystem = void 0;
-class DefaultHierarchicalMemorySystem {
-    constructor(dbPath, namespace) {
-        this.memory = new Map();
-        this.dbPath = dbPath;
-        this.namespace = namespace || 'default';
-    }
-    getNamespaceMap(namespace) {
-        if (!this.memory.has(namespace)) {
-            this.memory.set(namespace, new Map());
-        }
-        return this.memory.get(namespace);
-    }
-    async store(key, value) {
-        await this.storeInNamespace(this.namespace || 'default', key, value);
-    }
-    async retrieve(key) {
-        return this.retrieveFromNamespace(this.namespace || 'default', key);
-    }
-    async get(key) {
-        return this.retrieve(key);
-    }
-    async delete(key) {
-        const nsMap = this.getNamespaceMap(this.namespace || 'default');
-        return nsMap.delete(key);
-    }
-    async clear() {
-        await this.clearNamespace(this.namespace || 'default');
-    }
-    async list() {
-        const nsMap = this.getNamespaceMap(this.namespace || 'default');
-        return Array.from(nsMap.keys());
-    }
-    async exists(key) {
-        const nsMap = this.getNamespaceMap(this.namespace || 'default');
-        return nsMap.has(key);
-    }
-    async storeInNamespace(namespace, key, value) {
-        const nsMap = this.getNamespaceMap(namespace);
-        nsMap.set(key, value);
-    }
-    async retrieveFromNamespace(namespace, key) {
-        const nsMap = this.getNamespaceMap(namespace);
-        return nsMap.get(key);
-    }
-    async listNamespaces() {
-        return Array.from(this.memory.keys());
-    }
-    async clearNamespace(namespace) {
-        this.memory.delete(namespace);
-    }
-}
-exports.DefaultHierarchicalMemorySystem = DefaultHierarchicalMemorySystem;
-//# sourceMappingURL=hierarchical-memory-system.js.map

package/dist/memory/memory-system.d.ts

@@ -1,25 +0,0 @@
-/**
- * Basic Memory System Interface
- * Minimal implementation to satisfy missing imports
- */
-export interface MemorySystem {
-    store(key: string, value: any): Promise<void>;
-    retrieve(key: string): Promise<any>;
-    get(key: string): Promise<any>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-}
-export declare class BasicMemorySystem implements MemorySystem {
-    private memory;
-    store(key: string, value: any): Promise<void>;
-    retrieve(key: string): Promise<any>;
-    get(key: string): Promise<any>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-}
-export declare const defaultMemorySystem: BasicMemorySystem;
-//# sourceMappingURL=memory-system.d.ts.map

package/dist/memory/memory-system.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * Basic Memory System Interface
- * Minimal implementation to satisfy missing imports
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMemorySystem = exports.BasicMemorySystem = void 0;
-class BasicMemorySystem {
-    constructor() {
-        this.memory = new Map();
-    }
-    async store(key, value) {
-        this.memory.set(key, value);
-    }
-    async retrieve(key) {
-        return this.memory.get(key);
-    }
-    async get(key) {
-        return this.memory.get(key);
-    }
-    async delete(key) {
-        return this.memory.delete(key);
-    }
-    async clear() {
-        this.memory.clear();
-    }
-    async list() {
-        return Array.from(this.memory.keys());
-    }
-    async exists(key) {
-        return this.memory.has(key);
-    }
-}
-exports.BasicMemorySystem = BasicMemorySystem;
-exports.defaultMemorySystem = new BasicMemorySystem();
-//# sourceMappingURL=memory-system.js.map

package/dist/session/store.d.ts

@@ -1,47 +0,0 @@
-export interface SessionMessage {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string;
-    timestamp: string;
-    meta?: Record<string, unknown>;
-}
-export interface SessionRecord {
-    id: string;
-    startedAt: string;
-    endedAt?: string;
-    objective: string;
-    provider: {
-        id: string;
-        model: string;
-        baseURL?: string;
-    };
-    mcp: {
-        cmd: string;
-        args?: string[];
-    };
-    messages: SessionMessage[];
-    toolEvents?: {
-        name: string;
-        when: string;
-        argsPreview?: string;
-        resultPreview?: string;
-    }[];
-    summary?: string;
-}
-export declare function createSessionId(): string;
-export declare function startSession(rec: Omit<SessionRecord, 'messages' | 'toolEvents'> & {
-    messages?: SessionMessage[];
-}): SessionRecord;
-export declare function readSession(id: string): SessionRecord | undefined;
-export declare function listSessions(): {
-    id: string;
-    startedAt: string;
-    objective: string;
-}[];
-export declare function appendMessage(id: string, msg: SessionMessage): void;
-export declare function appendToolEvent(id: string, ev: {
-    name: string;
-    argsPreview?: string;
-    resultPreview?: string;
-}): void;
-export declare function endSession(id: string, summary?: string): void;
-//# sourceMappingURL=store.d.ts.map

package/dist/session/store.js

@@ -1,74 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSessionId = createSessionId;
-exports.startSession = startSession;
-exports.readSession = readSession;
-exports.listSessions = listSessions;
-exports.appendMessage = appendMessage;
-exports.appendToolEvent = appendToolEvent;
-exports.endSession = endSession;
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-function ensureDir(dir) {
-    if (!fs_1.default.existsSync(dir))
-        fs_1.default.mkdirSync(dir, { recursive: true });
-}
-function sessionsDir() {
-    const dir = path_1.default.join(os_1.default.homedir(), '.snow-flow', 'sessions');
-    ensureDir(dir);
-    return dir;
-}
-function createSessionId() {
-    return `sess_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function sessionPath(id) {
-    return path_1.default.join(sessionsDir(), `${id}.json`);
-}
-function startSession(rec) {
-    const full = { ...rec, messages: rec.messages ?? [], toolEvents: [] };
-    fs_1.default.writeFileSync(sessionPath(rec.id), JSON.stringify(full, null, 2), 'utf8');
-    return full;
-}
-function readSession(id) {
-    const p = sessionPath(id);
-    if (!fs_1.default.existsSync(p))
-        return undefined;
-    return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
-}
-function listSessions() {
-    const dir = sessionsDir();
-    const files = fs_1.default.readdirSync(dir).filter(f => f.endsWith('.json'));
-    return files.map(f => {
-        const rec = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, f), 'utf8'));
-        return { id: rec.id, startedAt: rec.startedAt, objective: rec.objective };
-    }).sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
-}
-function appendMessage(id, msg) {
-    const rec = readSession(id);
-    if (!rec)
-        return;
-    rec.messages.push(msg);
-    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
-}
-function appendToolEvent(id, ev) {
-    const rec = readSession(id);
-    if (!rec)
-        return;
-    const item = { name: ev.name, when: new Date().toISOString(), argsPreview: ev.argsPreview, resultPreview: ev.resultPreview };
-    (rec.toolEvents = rec.toolEvents || []).push(item);
-    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
-}
-function endSession(id, summary) {
-    const rec = readSession(id);
-    if (!rec)
-        return;
-    rec.endedAt = new Date().toISOString();
-    if (summary)
-        rec.summary = summary;
-    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
-}
-//# sourceMappingURL=store.js.map

package/dist/utils/chunking-manager.d.ts

@@ -1,39 +0,0 @@
-/**
- * Chunking Manager for Large ServiceNow Artifacts
- * Handles scripts >30k characters that exceed API token limits
- */
-export interface ChunkingStrategy {
-    maxChunkSize: number;
-    overlapSize: number;
-    chunkType: 'lines' | 'functions' | 'blocks';
-}
-export interface ScriptChunk {
-    index: number;
-    content: string;
-    startLine: number;
-    endLine: number;
-    type: 'complete' | 'partial_start' | 'partial_middle' | 'partial_end';
-    hasContext: boolean;
-}
-export declare class ChunkingManager {
-    /**
-     * Determine if script needs chunking
-     */
-    static needsChunking(script: string, maxSize?: number): boolean;
-    /**
-     * Split large script into manageable chunks
-     */
-    static chunkScript(script: string, strategy?: ChunkingStrategy): ScriptChunk[];
-    /**
-     * Generate instructions for manual large script handling
-     */
-    static generateManualInstructions(scriptName: string, scriptSize: number, chunks: ScriptChunk[]): string;
-    /**
-     * Attempt smart chunked update for large scripts
-     */
-    static attemptChunkedUpdate(client: any, table: string, sys_id: string, field: string, script: string): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-}
-//# sourceMappingURL=chunking-manager.d.ts.map

package/dist/utils/chunking-manager.js

@@ -1,142 +0,0 @@
-"use strict";
-/**
- * Chunking Manager for Large ServiceNow Artifacts
- * Handles scripts >30k characters that exceed API token limits
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChunkingManager = void 0;
-class ChunkingManager {
-    /**
-     * Determine if script needs chunking
-     */
-    static needsChunking(script, maxSize = 100000) {
-        return script.length > maxSize;
-    }
-    /**
-     * Split large script into manageable chunks
-     */
-    static chunkScript(script, strategy = {
-        maxChunkSize: 25000,
-        overlapSize: 500,
-        chunkType: 'functions'
-    }) {
-        const lines = script.split('\n');
-        const chunks = [];
-        if (!this.needsChunking(script)) {
-            return [{
-                    index: 0,
-                    content: script,
-                    startLine: 1,
-                    endLine: lines.length,
-                    type: 'complete',
-                    hasContext: true
-                }];
-        }
-        let currentChunk = '';
-        let currentStartLine = 1;
-        let chunkIndex = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const potentialChunk = currentChunk + line + '\n';
-            if (potentialChunk.length > strategy.maxChunkSize) {
-                // Current chunk is full, save it
-                if (currentChunk.trim()) {
-                    chunks.push({
-                        index: chunkIndex++,
-                        content: currentChunk.trim(),
-                        startLine: currentStartLine,
-                        endLine: i,
-                        type: chunkIndex === 0 ? 'partial_start' : 'partial_middle',
-                        hasContext: true
-                    });
-                }
-                // Start new chunk with overlap
-                const overlapLines = Math.min(Math.floor(strategy.overlapSize / 50), // Assume ~50 chars per line
-                10 // Max 10 lines overlap
-                );
-                const overlapStart = Math.max(0, i - overlapLines);
-                currentChunk = lines.slice(overlapStart, i + 1).join('\n') + '\n';
-                currentStartLine = overlapStart + 1;
-            }
-            else {
-                currentChunk += line + '\n';
-            }
-        }
-        // Add final chunk
-        if (currentChunk.trim()) {
-            chunks.push({
-                index: chunkIndex,
-                content: currentChunk.trim(),
-                startLine: currentStartLine,
-                endLine: lines.length,
-                type: 'partial_end',
-                hasContext: true
-            });
-        }
-        return chunks;
-    }
-    /**
-     * Generate instructions for manual large script handling
-     */
-    static generateManualInstructions(scriptName, scriptSize, chunks) {
-        return `
-🚨 LARGE SCRIPT DETECTED: ${scriptName} (${scriptSize.toLocaleString()} characters)
-
-⚠️ This script exceeds API token limits and cannot be updated automatically.
-
-🔧 MANUAL UPDATE REQUIRED:
-
-1. **Navigate to ServiceNow**:
-   - Go to Service Portal → Widgets
-   - Find and edit your widget
-   - Click on "Server Script" tab
-
-2. **Copy the updated script**:
-   - Script has been split into ${chunks.length} chunks below
-   - Copy ALL chunks in order and paste into ServiceNow
-
-3. **Chunks to copy**:
-${chunks.map(chunk => `
-   **Chunk ${chunk.index + 1}/${chunks.length}** (Lines ${chunk.startLine}-${chunk.endLine}):
-   \`\`\`javascript
-   ${chunk.content.substring(0, 500)}${chunk.content.length > 500 ? '...\n[truncated for display]' : ''}
-   \`\`\`
-`).join('')}
-
-4. **Validation**:
-   - Ensure no syntax errors after pasting
-   - Test widget functionality
-   - Consider breaking into smaller Script Includes
-
-💡 **Prevention for future**:
-- Keep server scripts under 30,000 characters
-- Use Script Includes for reusable functions
-- Move complex logic to business rules where appropriate
-`;
-    }
-    /**
-     * Attempt smart chunked update for large scripts
-     */
-    static async attemptChunkedUpdate(client, table, sys_id, field, script) {
-        if (!this.needsChunking(script)) {
-            // Not chunked, do normal update
-            try {
-                await client.updateRecord(table, sys_id, { [field]: script });
-                return { success: true, message: 'Script updated successfully' };
-            }
-            catch (error) {
-                return { success: false, message: `Update failed: ${error}` };
-            }
-        }
-        // For large scripts, we can't actually chunk the API call
-        // But we can provide intelligent guidance
-        const chunks = this.chunkScript(script);
-        const instructions = this.generateManualInstructions(field, script.length, chunks);
-        return {
-            success: false,
-            message: `Script too large for automatic update. Manual steps required:\n${instructions}`
-        };
-    }
-}
-exports.ChunkingManager = ChunkingManager;
-//# sourceMappingURL=chunking-manager.js.map