snow-flow 4.0.0 → 4.0.2

package/README.md

@@ -1,14 +1,14 @@
 <div align="center">
   <img src="assets/snow-flow-logo.svg" alt="Snow-Flow Logo" width="200" height="200">
   
-  # ❄️ Snow-Flow v3.6.25 ❄️
+  # ❄️ Snow-Flow v4.0.0 - Final Claude Code CLI Edition ❄️
   
   <p align="center">
     <strong>🚀 Revolutionary ServiceNow Development Framework with AI-Powered Automation</strong>
   </p>
   
   <p align="center">
-    <a href="https://www.npmjs.com/package/snow-flow"><img src="https://img.shields.io/npm/v/snow-flow.svg?style=for-the-badge&logo=npm&color=CB3837" alt="npm version"></a>
+    <a href="https://www.npmjs.com/package/snow-flow"><img src="https://img.shields.io/badge/npm-v4.0.0--final--claude-CB3837?style=for-the-badge&logo=npm" alt="npm version"></a>
     <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge" alt="License: MIT"></a>
     <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/snow-flow.svg?style=for-the-badge&logo=node.js&color=339933" alt="Node.js Version"></a>
     <a href="https://github.com/groeimetai/snow-flow"><img src="https://img.shields.io/github/stars/groeimetai/snow-flow?style=for-the-badge&logo=github" alt="GitHub Stars"></a>
@@ -21,29 +21,54 @@
 
 ---
 
-## 🎉 What's New in v3.6.25
+## 🚨 Important Announcement: Final Claude Code CLI Edition
+
+<div align="center">
+  <table>
+    <tr>
+      <td align="center">
+        <h3>⚡ This is the Final Claude Code CLI Version ⚡</h3>
+        <p>Snow-Flow v4.0.0 marks the end of an era. This is the last version designed specifically for Claude Code CLI.</p>
+        <p><strong>🔮 What's Coming Next:</strong></p>
+        <ul align="left">
+          <li>🤖 Support for <strong>ANY LLM</strong>: OpenAI, Google Gemini, Anthropic Claude, Ollama, and more</li>
+          <li>🔌 Modular provider system with unified interface</li>
+          <li>💻 Native CLI with interactive chat interface</li>
+          <li>🔄 Seamless switching between LLM providers</li>
+          <li>📊 Same great ServiceNow tools, now LLM-agnostic</li>
+        </ul>
+        <p><strong>Thank you to all Claude Code users who made this journey possible! 🙏</strong></p>
+      </td>
+    </tr>
+  </table>
+</div>
+
+---
+
+## 🎉 What's New in v4.0.0-final-claude
 
 <div align="center">
   <table>
     <tr>
       <td align="center" width="50%">
-        <h3>🚀 Major Features</h3>
+        <h3>🏁 Final Release Features</h3>
         <ul align="left">
-          <li><strong>Catalog UI Policy Deployment</strong><br/>Deploy via unified <code>snow_deploy</code> tool</li>
-          <li><strong>Knowledge Base Verification</strong><br/>Prevents orphaned articles with strict validation</li>
-          <li><strong>Catalog Variable Table Fix</strong><br/>Variables now use correct <code>item_option_new</code></li>
-          <li><strong>Enhanced UI Policy Debugging</strong><br/>Comprehensive reference field debugging</li>
-          <li><strong>18th MCP Server</strong><br/>Local Development Server for artifact syncing</li>
+          <li><strong>🔚 Final Claude Code CLI Version</strong><br/>Last release for Claude Code users</li>
+          <li><strong>📚 Complete Feature Set</strong><br/>All 18 MCP servers, 200+ tools</li>
+          <li><strong>🎯 Catalog UI Policy Support</strong><br/>Deploy via unified <code>snow_deploy</code> tool</li>
+          <li><strong>🔒 Knowledge Base Verification</strong><br/>Prevents orphaned articles</li>
+          <li><strong>✨ Beautiful Documentation</strong><br/>Enhanced README and website</li>
         </ul>
       </td>
       <td align="center" width="50%">
-        <h3>🔧 Critical Fixes</h3>
+        <h3>🚀 Latest Improvements</h3>
         <ul align="left">
-          <li>✅ Catalog variables now visible in ServiceNow</li>
-          <li>✅ UI policy actions reference fields fixed</li>
-          <li>✅ Non-existent KB error handling added</li>
-          <li>✅ MCP transport 3x faster operations</li>
-          <li>✅ Widget coherence validation improved</li>
+          <li>✅ Catalog variables table fix (v3.6.23)</li>
+          <li>✅ UI policy debugging enhanced (v3.6.22)</li>
+          <li>✅ Knowledge validation added (v3.6.25)</li>
+          <li>✅ MCP transport 3x faster</li>
+          <li>✅ ES5 validation throughout</li>
+          <li>🎁 All previous fixes included</li>
         </ul>
       </td>
     </tr>

package/dist/agent/interactive.d.ts

@@ -0,0 +1,11 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+import type { ProviderOptions } from '../llm/providers';
+export interface InteractiveOptions extends ProviderOptions {
+    system?: string;
+    mcp: SnowFlowConfig['mcp'];
+    maxSteps?: number;
+    showReasoning?: boolean;
+    resumeId?: string;
+}
+export declare function runInteractive(opts: InteractiveOptions): Promise<void>;
+//# sourceMappingURL=interactive.d.ts.map

package/dist/agent/interactive.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractive = runInteractive;
+const bridge_1 = require("../mcp/bridge");
+const chalk_1 = __importDefault(require("chalk"));
+const boxen_1 = __importDefault(require("boxen"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const store_js_1 = require("../session/store.js");
+const ora_1 = __importDefault(require("ora"));
+async function runInteractive(opts) {
+    const { provider, model, baseURL, apiKeyEnv, system, mcp, maxSteps = 40, showReasoning = true, resumeId } = opts;
+    // Resolve model
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const prov = require('../llm/providers.js');
+    const llm = prov.getModel({ provider, model, baseURL, apiKeyEnv });
+    const sessionId = resumeId || (0, store_js_1.createSessionId)();
+    (0, store_js_1.startSession)({
+        id: sessionId,
+        startedAt: new Date().toISOString(),
+        objective: '(interactive)',
+        provider: { id: String(provider), model: String(model), baseURL },
+        mcp: { cmd: mcp.cmd, args: mcp.args },
+    });
+    process.stdout.write(chalk_1.default.bold(`\nSnow-Flow Interactive (${provider}:${model})`) + "\n");
+    process.stdout.write(chalk_1.default.gray('Tips: ESC ESC = vorige assistant-antwoord | /quit om te stoppen') + "\n\n");
+    // Load tools once with spinner
+    const spinner = (0, ora_1.default)('MCP-tools laden...').start();
+    const { tools, close } = await (0, bridge_1.loadMCPTools)(mcp).finally(() => spinner.stop());
+    const messages = [];
+    if (system)
+        messages.push({ role: 'system', content: system });
+    // Preload previous messages if resuming
+    if (resumeId) {
+        try {
+            const { readSession } = require('../session/store.js');
+            const rec = readSession(resumeId);
+            if (rec?.messages?.length) {
+                const recent = rec.messages.filter((m) => m.role === 'user' || m.role === 'assistant').slice(-20);
+                for (const m of recent)
+                    messages.push({ role: m.role, content: m.content });
+            }
+        }
+        catch { }
+    }
+    // Key handling for ESC ESC
+    node_readline_1.default.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    let lastEsc = 0;
+    let lastAssistant = null;
+    let showTools = true;
+    const onKeypress = (_str, key) => {
+        if (!key)
+            return;
+        if (key.name === 'escape') {
+            const now = Date.now();
+            if (now - lastEsc < 500) {
+                // double ESC
+                if (lastAssistant) {
+                    const box = (0, boxen_1.default)(lastAssistant.slice(0, 1200) + (lastAssistant.length > 1200 ? '…' : ''), { padding: 1, borderColor: 'yellow', title: 'Vorige assistant', titleAlignment: 'center' });
+                    process.stdout.write('\n' + box + '\n');
+                }
+                else {
+                    process.stdout.write(chalk_1.default.gray('\nGeen vorige assistant-respons beschikbaar.') + '\n');
+                }
+            }
+            lastEsc = now;
+        }
+        if (key.name === 't') {
+            showTools = !showTools;
+            process.stdout.write('\n' + (showTools ? chalk_1.default.gray('Tool events: ON') : chalk_1.default.gray('Tool events: OFF')) + '\n');
+        }
+        if (key.name === 'h') {
+            const last = messages.slice(-6);
+            const text = last.map(m => `${m.role}> ${m.content}`).join('\n');
+            const panel = (0, boxen_1.default)(text, { padding: 1, borderColor: 'blue', title: 'History (tail)', titleAlignment: 'center' });
+            process.stdout.write('\n' + panel + '\n');
+        }
+        if (key.name === 's') {
+            const fs = require('fs');
+            const out = (lastAssistant || '').toString();
+            const outPath = `${process.env.HOME || ''}/.snow-flow/sessions/${sessionId}.txt`;
+            try {
+                fs.writeFileSync(outPath, out, 'utf8');
+            }
+            catch { }
+            process.stdout.write(chalk_1.default.gray(`Saved assistant output to ${outPath}`) + '\n');
+        }
+    };
+    process.stdin.on('keypress', onKeypress);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { streamText } = require('ai');
+    const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    try {
+        const onSignal = async () => {
+            try {
+                await close();
+            }
+            catch { }
+            (0, store_js_1.endSession)(sessionId);
+            process.stdout.write('\n' + chalk_1.default.gray('Session ended.') + '\n');
+            process.exit(0);
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        // loop
+        while (true) {
+            const input = await ask(chalk_1.default.cyan('You: '));
+            if (!input)
+                continue;
+            if (input.trim() === '/quit')
+                break;
+            const long = input.length > 1200;
+            if (long) {
+                const preview = input.slice(0, 1200) + '…';
+                const box = (0, boxen_1.default)(preview, { padding: 1, borderColor: 'green', title: 'Preview (truncated)', titleAlignment: 'center' });
+                process.stdout.write('\n' + box + '\n');
+                const confirm = await ask(chalk_1.default.gray('Doorgaan met verzenden? [y/N] '));
+                if (!/^y(es)?$/i.test(confirm.trim()))
+                    continue;
+            }
+            messages.push({ role: 'user', content: input });
+            (0, store_js_1.appendMessage)(sessionId, { role: 'user', content: input, timestamp: new Date().toISOString() });
+            const result = await streamText({
+                model: llm,
+                system,
+                messages,
+                tools,
+                maxSteps,
+            });
+            let buffer = '';
+            let inReasoning = false;
+            const write = (s) => {
+                buffer += s;
+                const out = inReasoning && showReasoning ? chalk_1.default.yellow.dim(s) : s;
+                process.stdout.write(out);
+            };
+            if (result.toolCallStream && typeof result.toolCallStream[Symbol.asyncIterator] === 'function') {
+                (async () => {
+                    for await (const ev of result.toolCallStream) {
+                        const name = ev?.toolName || ev?.name || 'tool';
+                        const args = ev?.args ? JSON.stringify(ev.args).slice(0, 180) : '';
+                        if (showTools)
+                            process.stdout.write('\n' + chalk_1.default.cyan(`🔧 Tool → ${name} ${args}`) + '\n');
+                        (0, store_js_1.appendToolEvent)(sessionId, { name, argsPreview: args });
+                    }
+                })().catch(() => { });
+            }
+            if (result.toolResultStream && typeof result.toolResultStream[Symbol.asyncIterator] === 'function') {
+                (async () => {
+                    for await (const ev of result.toolResultStream) {
+                        const name = ev?.toolName || ev?.name || 'tool';
+                        const out = ev?.result ? JSON.stringify(ev.result).slice(0, 180) : '';
+                        if (showTools)
+                            process.stdout.write(chalk_1.default.magenta(`📦 Result ← ${name} ${out}`) + '\n');
+                        (0, store_js_1.appendToolEvent)(sessionId, { name, resultPreview: out });
+                    }
+                })().catch(() => { });
+            }
+            process.stdout.write(chalk_1.default.green('\nAssistant: '));
+            for await (const chunk of result.textStream) {
+                const s = String(chunk);
+                if (showReasoning) {
+                    if (s.includes('```reasoning') || s.toLowerCase().includes('<thinking>') || /\[\s*reasoning\s*\]/i.test(s))
+                        inReasoning = true;
+                    if (s.includes('```') || s.toLowerCase().includes('</thinking>'))
+                        inReasoning = false;
+                }
+                write(s);
+            }
+            process.stdout.write('\n');
+            lastAssistant = buffer;
+            messages.push({ role: 'assistant', content: buffer });
+            (0, store_js_1.appendMessage)(sessionId, { role: 'assistant', content: buffer, timestamp: new Date().toISOString() });
+        }
+    }
+    finally {
+        rl.close();
+        process.stdin.off('keypress', onKeypress);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        await close();
+        (0, store_js_1.endSession)(sessionId);
+    }
+}
+//# sourceMappingURL=interactive.js.map

package/dist/agent/session.d.ts

@@ -0,0 +1,12 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+import type { ProviderOptions } from '../llm/providers';
+export interface AgentRunOptions extends ProviderOptions {
+    system?: string;
+    user: string;
+    mcp: SnowFlowConfig['mcp'];
+    maxSteps?: number;
+    showReasoning?: boolean;
+    saveOutputPath?: string;
+}
+export declare function runAgent(opts: AgentRunOptions): Promise<void>;
+//# sourceMappingURL=session.d.ts.map

package/dist/agent/session.js

@@ -0,0 +1,106 @@
+"use strict";
+// Agent session placeholder to keep build green.
+// Will be replaced with streaming + tool-calling using the AI SDK.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
+const bridge_1 = require("../mcp/bridge");
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+async function runAgent(opts) {
+    const { mcp, system, user, maxSteps = 40, provider, model, baseURL, apiKeyEnv, showReasoning = true, saveOutputPath } = opts;
+    // Resolve model via provider registry
+    let llm;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const prov = require('../llm/providers.js');
+        llm = prov.getModel({ provider, model, baseURL, apiKeyEnv });
+    }
+    catch (e) {
+        console.error('❌ LLM provider init error:', e instanceof Error ? e.message : String(e));
+        throw e;
+    }
+    // Load MCP tools (if AI SDK MCP client is available)
+    const { tools, close } = await (0, bridge_1.loadMCPTools)(mcp);
+    // Stream using AI SDK
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { streamText } = require('ai');
+        const sessionId = (0, store_js_1.createSessionId)();
+        (0, store_js_1.startSession)({
+            id: sessionId,
+            startedAt: new Date().toISOString(),
+            objective: user,
+            provider: { id: String(provider), model: String(model), baseURL },
+            mcp: { cmd: mcp.cmd, args: mcp.args },
+        });
+        (0, store_js_1.appendMessage)(sessionId, { role: 'user', content: user, timestamp: new Date().toISOString() });
+        const result = await streamText({
+            model: llm,
+            system: system ?? 'You are Snow-Flow, a ServiceNow engineering agent. Be precise. Use tools when helpful.',
+            messages: [{ role: 'user', content: user }],
+            tools,
+            maxSteps,
+        });
+        let buffer = '';
+        let inReasoning = false;
+        const writeChunk = (s) => {
+            buffer += s;
+            const colored = inReasoning && showReasoning ? chalk_1.default.yellow.dim(s) : s;
+            process.stdout.write(colored);
+        };
+        // Optional: stream tool call events if provided by SDK
+        if (result.toolCallStream && typeof result.toolCallStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolCallStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const args = ev?.args ? JSON.stringify(ev.args).slice(0, 200) : '';
+                    process.stdout.write('\n' + chalk_1.default.cyan(`🔧 Tool → ${name} ${args}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, argsPreview: args });
+                }
+            })().catch(() => { });
+        }
+        if (result.toolResultStream && typeof result.toolResultStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolResultStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const out = ev?.result ? JSON.stringify(ev.result).slice(0, 200) : '';
+                    process.stdout.write(chalk_1.default.magenta(`📦 Result ← ${name} ${out}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, resultPreview: out });
+                }
+            })().catch(() => { });
+        }
+        for await (const chunk of result.textStream) {
+            const str = String(chunk);
+            // Heuristic: detect reasoning blocks (```reasoning, <thinking>, [reasoning])
+            if (showReasoning) {
+                if (str.includes('```reasoning') || str.toLowerCase().includes('<thinking>') || /\[\s*reasoning\s*\]/i.test(str))
+                    inReasoning = true;
+                if (str.includes('```') || str.toLowerCase().includes('</thinking>'))
+                    inReasoning = false;
+            }
+            writeChunk(str);
+        }
+        // Render a boxed summary if output is long
+        if (buffer.length > 4000) {
+            const preview = buffer.slice(0, 1200) + '…';
+            const box = (0, boxen_1.default)(preview, { padding: 1, borderColor: 'green', title: 'Preview (truncated)', titleAlignment: 'center' });
+            process.stdout.write('\n' + box + '\n');
+            process.stdout.write(chalk_1.default.gray(`Full length: ${buffer.length} chars`) + '\n');
+        }
+        if (saveOutputPath) {
+            const fs = require('fs');
+            fs.writeFileSync(saveOutputPath, buffer, 'utf8');
+            process.stdout.write(chalk_1.default.gray(`Saved full output to ${saveOutputPath}`) + '\n');
+        }
+        (0, store_js_1.appendMessage)(sessionId, { role: 'assistant', content: buffer, timestamp: new Date().toISOString() });
+        (0, store_js_1.endSession)(sessionId);
+    }
+    finally {
+        await close();
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/cli/auth.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerAuthCommands(program: Command): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/auth.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthCommands = registerAuthCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const keys_js_1 = require("../llm/keys.js");
+function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Manage provider API credentials for Snow-Flow');
+    auth
+        .command('login')
+        .description('Interactive login to store API keys for a provider')
+        .option('--provider <provider>', 'Provider id (openai|google|openrouter|openai-compatible|ollama)')
+        .action(async (opts) => {
+        const p = opts.provider || (await inquirer_1.default.prompt([{ name: 'provider', message: 'Provider', type: 'list', choices: ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'] }])).provider;
+        const existing = (0, keys_js_1.getApiKey)(p);
+        const { apiKey } = await inquirer_1.default.prompt([{ name: 'apiKey', message: `API key for ${p}${existing ? ' (leave blank to keep existing)' : ''}`, type: 'password', mask: '*' }]);
+        if (!apiKey && existing) {
+            console.log(chalk_1.default.yellow('Keeping existing key.'));
+            return;
+        }
+        if (!apiKey) {
+            console.error(chalk_1.default.red('No key entered. Aborting.'));
+            process.exit(1);
+        }
+        (0, keys_js_1.setApiKey)(p, apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${p}.`));
+    });
+    auth
+        .command('set-key')
+        .description('Set API key non-interactively')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .requiredOption('--api-key <key>', 'API key value')
+        .action((opts) => {
+        (0, keys_js_1.setApiKey)(opts.provider, opts.apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${opts.provider}.`));
+    });
+    auth
+        .command('show')
+        .description('Show configured providers (keys partially masked)')
+        .action(() => {
+        const entries = (0, keys_js_1.listKeys)();
+        for (const [p, v] of Object.entries(entries)) {
+            const mask = v ? `${v.substring(0, 4)}…${v.substring(v.length - 4)}` : '—';
+            console.log(`${p.padEnd(18)} ${mask}`);
+        }
+    });
+    auth
+        .command('clear')
+        .description('Clear a stored API key')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .action((opts) => {
+        (0, keys_js_1.clearApiKey)(opts.provider);
+        console.log(chalk_1.default.yellow(`Cleared API key for ${opts.provider}.`));
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/session.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerSessionCommands(program: Command): void;
+//# sourceMappingURL=session.d.ts.map

package/dist/cli/session.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionCommands = registerSessionCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+function registerSessionCommands(program) {
+    const sess = program.command('session').description('Manage and inspect Snow-Flow sessions');
+    sess
+        .command('list')
+        .description('List recent sessions')
+        .action(() => {
+        const rows = (0, store_js_1.listSessions)().slice(0, 30);
+        if (!rows.length)
+            return console.log('No sessions yet.');
+        for (const r of rows) {
+            console.log(`${chalk_1.default.gray(r.startedAt)}  ${chalk_1.default.cyan(r.id)}  ${r.objective}`);
+        }
+    });
+    sess
+        .command('show <id>')
+        .description('Show session details')
+        .action((id) => {
+        const rec = (0, store_js_1.readSession)(id);
+        if (!rec)
+            return console.error(chalk_1.default.red('Session not found.'));
+        console.log(chalk_1.default.cyan(`Session ${rec.id}`));
+        console.log(`${chalk_1.default.gray(rec.startedAt)} → ${chalk_1.default.gray(rec.endedAt ?? '…')}`);
+        console.log('Objective:', rec.objective);
+        console.log('Provider:', `${rec.provider.id} ${rec.provider.model}`);
+        console.log('MCP:', `${rec.mcp.cmd} ${(rec.mcp.args || []).join(' ')}`);
+        console.log('\nMessages:');
+        for (const m of rec.messages) {
+            console.log(`- ${chalk_1.default.yellow(m.role)} ${chalk_1.default.gray(m.timestamp)}\n  ${m.content.slice(0, 400)}${m.content.length > 400 ? '…' : ''}`);
+        }
+        if (rec.toolEvents?.length) {
+            console.log('\nTool events:');
+            for (const ev of rec.toolEvents) {
+                console.log(`  🔧 ${ev.name} ${chalk_1.default.gray(ev.when)} ${ev.argsPreview ? ('args:' + ev.argsPreview) : ''} ${ev.resultPreview ? ('res:' + ev.resultPreview) : ''}`);
+            }
+        }
+    });
+}
+//# sourceMappingURL=session.js.map

package/dist/cli.js

@@ -53,6 +53,11 @@ const agent_detector_js_1 = require("./utils/agent-detector.js");
 const version_js_1 = require("./version.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
+// New provider-agnostic engine imports (compile-safe placeholders)
+const llm_config_loader_js_1 = require("./config/llm-config-loader.js");
+const interactive_js_1 = require("./agent/interactive.js");
+const auth_js_1 = require("./cli/auth.js");
+const session_js_1 = require("./cli/session.js");
 // Load environment variables
 dotenv_1.default.config();
 // Create CLI logger instance
@@ -62,6 +67,10 @@ program
     .name('snow-flow')
     .description('ServiceNow Multi-Agent Development Framework')
     .version(version_js_1.VERSION);
+// Register auth commands (API key management)
+(0, auth_js_1.registerAuthCommands)(program);
+// Register session inspection commands
+(0, session_js_1.registerSessionCommands)(program);
 // Flow deprecation handler - check for flow-related commands
 function checkFlowDeprecation(command, objective) {
     const flowKeywords = ['flow', 'create-flow', 'xml-flow', 'flow-designer'];
@@ -90,6 +99,18 @@ function checkFlowDeprecation(command, objective) {
 program
     .command('swarm <objective>')
     .description('Execute multi-agent orchestration for a ServiceNow task - één command voor alles!')
+    // New engine selector: defaults to auto (uses config-driven agent when available)
+    .option('--engine <engine>', 'Execution engine (auto|agent|claude)', 'auto')
+    .option('--config <path>', 'Path to snowflow.config file')
+    .option('--show-reasoning', 'Show LLM reasoning in a different color (default)', true)
+    .option('--no-show-reasoning', 'Hide LLM reasoning blocks')
+    .option('--save-output <path>', 'Save full assistant output to a file')
+    .option('--resume <sessionId>', 'Resume an existing interactive session')
+    // Provider overrides (optional, config-driven by default)
+    .option('--provider <provider>', 'LLM provider override')
+    .option('--model <model>', 'Model override')
+    .option('--base-url <url>', 'Base URL override for openai-compatible or gateways')
+    .option('--api-key-env <name>', 'Use specific API key env var')
     .option('--strategy <strategy>', 'Execution strategy (development, _analysis, research)', 'development')
     .option('--mode <mode>', 'Coordination mode (hierarchical, mesh, distributed)', 'hierarchical')
     .option('--max-agents <number>', 'Maximum number of agents', '5')
@@ -266,6 +287,66 @@ program
             cliLogger.info(`🤖 Autonomous Systems: ❌ All Disabled`);
         }
     }
+    // Detect agent engine via config (provider-agnostic) when requested or available
+    const shouldUseAgent = (() => {
+        if (options.engine === 'agent')
+            return true;
+        if (options.engine === 'claude')
+            return false;
+        // auto: use agent when config file is present and valid
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        return Boolean(cfg && cfg.llm && cfg.llm.provider && cfg.llm.model);
+    })();
+    if (shouldUseAgent) {
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        if (!cfg) {
+            cliLogger.error('❌ Geen snowflow.config.(json|js|cjs) gevonden. Voeg config toe of gebruik --engine claude.');
+            process.exit(1);
+        }
+        // Basic validation for MVP
+        if (!cfg.llm?.provider || !cfg.llm?.model) {
+            cliLogger.error('❌ Config mist llm.provider of llm.model');
+            process.exit(1);
+        }
+        cliLogger.info('\n🤖 Using provider-agnostic Snow-Flow agent (interactive)');
+        try {
+            await (0, interactive_js_1.runInteractive)({
+                provider: cfg.llm.provider,
+                model: String(cfg.llm.model),
+                baseURL: cfg.llm.baseURL,
+                apiKeyEnv: cfg.llm.apiKeyEnv,
+                mcp: cfg.mcp,
+                system: cfg.agent?.system,
+                maxSteps: cfg.agent?.maxSteps ?? 40,
+                showReasoning: options.showReasoning !== false,
+                resumeId: options.resume || undefined,
+            });
+        }
+        catch (e) {
+            cliLogger.error('❌ Interactive agent error:', e instanceof Error ? e.message : String(e));
+        }
+        return; // end here; skip legacy Claude path
+    }
     // Analyze the objective using intelligent agent detection
     const taskAnalysis = analyzeObjective(objective, parseInt(options.maxAgents));
     // Debug logging to understand task type detection

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.6.25';
+    return '4.0.0';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();