morpheus-cli 0.1.0

package/dist/runtime/__tests__/agent.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Agent } from '../agent.js';
+import { ProviderFactory } from '../providers/factory.js';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+import { AIMessage } from '@langchain/core/messages';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { homedir } from 'os';
+vi.mock('../providers/factory.js');
+describe('Agent', () => {
+    let agent;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Clean up any existing test database
+        const defaultDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        if (fs.existsSync(defaultDbPath)) {
+            try {
+                const Database = (await import("better-sqlite3")).default;
+                const db = new Database(defaultDbPath);
+                db.exec("DELETE FROM messages");
+                db.close();
+            }
+            catch (err) {
+                // Ignore errors if database doesn't exist or is corrupted
+            }
+        }
+        mockProvider.invoke.mockResolvedValue(new AIMessage('Hello world'));
+        vi.mocked(ProviderFactory.create).mockReturnValue(mockProvider);
+        agent = new Agent(DEFAULT_CONFIG);
+    });
+    afterEach(async () => {
+        // Clean up after each test
+        if (agent) {
+            try {
+                await agent.clearMemory();
+            }
+            catch (err) {
+                // Ignore cleanup errors
+            }
+        }
+    });
+    it('should initialize successfully', async () => {
+        await agent.initialize();
+        expect(ProviderFactory.create).toHaveBeenCalledWith(DEFAULT_CONFIG.llm);
+    });
+    it('should chat successfully', async () => {
+        await agent.initialize();
+        const response = await agent.chat('Hi');
+        expect(response).toBe('Hello world');
+        expect(mockProvider.invoke).toHaveBeenCalled();
+    });
+    it('should throw if not initialized', async () => {
+        await expect(agent.chat('Hi')).rejects.toThrow('initialize() first');
+    });
+    it('should maintain history', async () => {
+        await agent.initialize();
+        // Clear any residual history from previous tests
+        await agent.clearMemory();
+        // First turn
+        await agent.chat('Hi');
+        const history1 = await agent.getHistory();
+        expect(history1).toHaveLength(2);
+        expect(history1[0].content).toBe('Hi'); // User
+        expect(history1[1].content).toBe('Hello world'); // AI
+        // Second turn
+        // Update mock return value for next call
+        mockProvider.invoke.mockResolvedValue(new AIMessage('I am fine'));
+        await agent.chat('How are you?');
+        const history2 = await agent.getHistory();
+        expect(history2).toHaveLength(4);
+        expect(history2[2].content).toBe('How are you?');
+        expect(history2[3].content).toBe('I am fine');
+    });
+    describe('Configuration Validation', () => {
+        it('should throw if llm provider is missing', async () => {
+            const invalidConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+            delete invalidConfig.llm.provider; // Invalid
+            const badAgent = new Agent(invalidConfig);
+            await expect(badAgent.initialize()).rejects.toThrow('LLM provider not specified');
+        });
+        it('should propagate ProviderError during initialization', async () => {
+            const mockError = new Error("Mock Factory Error");
+            vi.mocked(ProviderFactory.create).mockImplementation(() => { throw mockError; });
+            // ProviderError constructs message as: "Provider {provider} failed: {originalError.message}"
+            await expect(agent.initialize()).rejects.toThrow('Provider openai failed: Mock Factory Error');
+        });
+    });
+});

package/dist/runtime/__tests__/agent_persistence.test.js

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Agent } from "../agent.js";
+import { ProviderFactory } from "../providers/factory.js";
+import { DEFAULT_CONFIG } from "../../types/config.js";
+import { AIMessage } from "@langchain/core/messages";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { tmpdir } from "os";
+import { homedir } from "os";
+vi.mock("../providers/factory.js");
+describe("Agent Persistence Integration", () => {
+    let agent;
+    let testDbPath;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Clean up by clearing all data from the database (safer than deleting the locked file)
+        const defaultDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        if (fs.existsSync(defaultDbPath)) {
+            try {
+                const Database = (await import("better-sqlite3")).default;
+                const db = new Database(defaultDbPath);
+                db.exec("DELETE FROM messages");
+                db.close();
+            }
+            catch (err) {
+                // Ignore errors if database doesn't exist or is corrupted
+            }
+        }
+        // Create a temporary test database path
+        const tempDir = path.join(tmpdir(), "morpheus-test-agent", Date.now().toString());
+        testDbPath = path.join(tempDir, "short-memory.db");
+        // Mock the SQLiteChatMessageHistory to use test path
+        // We'll use the default ~/.morpheus path for this test
+        mockProvider.invoke.mockResolvedValue(new AIMessage("Test response"));
+        vi.mocked(ProviderFactory.create).mockReturnValue(mockProvider);
+        agent = new Agent(DEFAULT_CONFIG);
+    });
+    afterEach(async () => {
+        // Clean up test database
+        const defaultDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        if (fs.existsSync(defaultDbPath)) {
+            // We can't delete it if it's open, so we'll just clear it
+            // The agent should have closed the connection
+        }
+    });
+    describe("Database File Creation", () => {
+        it("should create database file on initialization", async () => {
+            await agent.initialize();
+            const defaultDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+            expect(fs.existsSync(defaultDbPath)).toBe(true);
+        });
+    });
+    describe("Message Persistence", () => {
+        it("should persist messages to database", async () => {
+            await agent.initialize();
+            // Send a message
+            await agent.chat("Hello, Agent!");
+            // Verify history contains the message
+            const history = await agent.getHistory();
+            expect(history).toHaveLength(2); // User message + AI response
+            expect(history[0].content).toBe("Hello, Agent!");
+            expect(history[1].content).toBe("Test response");
+        });
+        it("should restore conversation history on restart", async () => {
+            // First session: send a message
+            await agent.initialize();
+            await agent.chat("Remember this message");
+            const firstHistory = await agent.getHistory();
+            expect(firstHistory).toHaveLength(2);
+            // Simulate restart: create new agent instance
+            const agent2 = new Agent(DEFAULT_CONFIG);
+            await agent2.initialize();
+            // Verify history was restored
+            const restoredHistory = await agent2.getHistory();
+            expect(restoredHistory.length).toBeGreaterThanOrEqual(2);
+            // Check that the old messages are present
+            const contents = restoredHistory.map(m => m.content);
+            expect(contents).toContain("Remember this message");
+            expect(contents).toContain("Test response");
+        });
+        it("should accumulate messages across multiple conversations", async () => {
+            await agent.initialize();
+            // First conversation
+            await agent.chat("First message");
+            // Second conversation
+            mockProvider.invoke.mockResolvedValue(new AIMessage("Second response"));
+            await agent.chat("Second message");
+            // Verify all messages are persisted
+            const history = await agent.getHistory();
+            expect(history).toHaveLength(4);
+            expect(history[0].content).toBe("First message");
+            expect(history[1].content).toBe("Test response");
+            expect(history[2].content).toBe("Second message");
+            expect(history[3].content).toBe("Second response");
+        });
+    });
+    describe("Memory Clearing", () => {
+        it("should clear all persisted messages", async () => {
+            await agent.initialize();
+            // Add some messages
+            await agent.chat("Message 1");
+            await agent.chat("Message 2");
+            // Verify messages exist
+            let history = await agent.getHistory();
+            expect(history.length).toBeGreaterThan(0);
+            // Clear memory
+            await agent.clearMemory();
+            // Verify messages are cleared
+            history = await agent.getHistory();
+            expect(history).toEqual([]);
+        });
+        it("should start fresh after clearing memory", async () => {
+            await agent.initialize();
+            // Add and clear messages
+            await agent.chat("Old message");
+            await agent.clearMemory();
+            // Add new message
+            mockProvider.invoke.mockResolvedValue(new AIMessage("New response"));
+            await agent.chat("New message");
+            // Verify only new messages exist
+            const history = await agent.getHistory();
+            expect(history).toHaveLength(2);
+            expect(history[0].content).toBe("New message");
+            expect(history[1].content).toBe("New response");
+        });
+    });
+    describe("Context Preservation", () => {
+        it("should include history in conversation context", async () => {
+            await agent.initialize();
+            // First message
+            await agent.chat("My name is Alice");
+            // Second message (should have context)
+            mockProvider.invoke.mockResolvedValue(new AIMessage("Hello Alice!"));
+            await agent.chat("What is my name?");
+            // Verify the provider was called with full history
+            const lastCall = mockProvider.invoke.mock.calls[1];
+            const messagesPassedToLLM = lastCall[0];
+            // Should include: system message, previous user message, previous AI response, new user message
+            expect(messagesPassedToLLM.length).toBeGreaterThanOrEqual(4);
+            // Check that context includes the original message
+            const contents = messagesPassedToLLM.map((m) => m.content);
+            expect(contents).toContain("My name is Alice");
+        });
+    });
+});

package/dist/runtime/__tests__/display.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DisplayManager } from '../display.js';
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+// Hoisted mocks to ensure they are available for the module mock factory
+const mocks = vi.hoisted(() => {
+    return {
+        start: vi.fn(),
+        stop: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        loggerLog: vi.fn(),
+    };
+});
+// We need a way to control isSpinning. 
+// Since the factory runs hoisting, we can't easily closure over a let variable unless we put it on the mocks object or similar.
+// But we can just make the mock implementation toggle a property on itself or use a side channel?
+// Simplest: Mock object manages its own state? No, DisplayManager reads `.isSpinning`.
+// Let's implement logic IN the mock.
+let isSpinningInternal = false;
+vi.mock('ora', () => {
+    return {
+        default: vi.fn(() => ({
+            start: mocks.start.mockImplementation(() => { isSpinningInternal = true; }),
+            stop: mocks.stop.mockImplementation(() => { isSpinningInternal = false; }),
+            succeed: mocks.succeed.mockImplementation(() => { isSpinningInternal = false; }),
+            fail: mocks.fail.mockImplementation(() => { isSpinningInternal = false; }),
+            get isSpinning() { return isSpinningInternal; },
+            set text(val) { },
+            get text() { return 'loading...'; }
+        }))
+    };
+});
+vi.mock('winston', () => ({
+    default: {
+        createLogger: vi.fn(() => ({
+            log: mocks.loggerLog,
+        })),
+        format: {
+            combine: vi.fn(),
+            timestamp: vi.fn(),
+            printf: vi.fn(),
+        },
+        transports: {
+            DailyRotateFile: vi.fn(),
+        }
+    }
+}));
+vi.mock('winston-daily-rotate-file', () => {
+    return {
+        default: vi.fn()
+    };
+});
+describe('DisplayManager', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        isSpinningInternal = false;
+        // We cannot reset the singleton instance as it is private and static.
+        // So we must ensure state is consistent via public API in tests or beforeEach.
+        const dm = DisplayManager.getInstance();
+        dm.stopSpinner();
+    });
+    it('should be a singleton', () => {
+        const instance1 = DisplayManager.getInstance();
+        const instance2 = DisplayManager.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('should start spinner', () => {
+        const dm = DisplayManager.getInstance();
+        dm.startSpinner('test spinner');
+        expect(mocks.start).toHaveBeenCalledWith('test spinner');
+        expect(isSpinningInternal).toBe(true);
+    });
+    it('should not start spinner again if already spinning', () => {
+        const dm = DisplayManager.getInstance();
+        dm.startSpinner('first');
+        expect(mocks.start).toHaveBeenCalledTimes(1);
+        // Call again
+        dm.startSpinner('second');
+        expect(mocks.start).toHaveBeenCalledTimes(1); // Should not call start again
+        // It might update text, but start is not called
+    });
+    it('should stop spinner', () => {
+        const dm = DisplayManager.getInstance();
+        dm.startSpinner();
+        dm.stopSpinner();
+        expect(mocks.stop).toHaveBeenCalled();
+        expect(isSpinningInternal).toBe(false);
+    });
+    it('should log message and preserve spinner state', () => {
+        const dm = DisplayManager.getInstance();
+        dm.startSpinner('spinning');
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        dm.log('hello world');
+        // Flow: stop spinner -> log -> start spinner
+        // Calls: start(spinning) -> stop() -> log -> start(spinning)
+        // Check stop called (after initial start)
+        expect(mocks.stop).toHaveBeenCalled();
+        // Check log called
+        expect(consoleSpy).toHaveBeenCalledWith('hello world');
+        // Check start called again (restore)
+        // Total start calls: 1 (initial) + 1 (restore) = 2
+        expect(mocks.start).toHaveBeenCalledTimes(2);
+        expect(mocks.start).toHaveBeenLastCalledWith('loading...'); // Use mocked text getter
+    });
+    it('should log message without spinner interaction if not spinning', () => {
+        const dm = DisplayManager.getInstance();
+        // Ensure stopped
+        dm.stopSpinner();
+        vi.clearAllMocks(); // Clear calls from setup
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        dm.log('hello world');
+        expect(mocks.stop).not.toHaveBeenCalled();
+        expect(mocks.start).not.toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith('hello world');
+    });
+    it('should initialize logger with config', async () => {
+        const dm = DisplayManager.getInstance();
+        await dm.initialize({ enabled: true, level: 'info', retention: '14d' });
+        expect(winston.createLogger).toHaveBeenCalled();
+        // Check DailyRotateFile instantiation
+        expect(DailyRotateFile).toHaveBeenCalledWith(expect.objectContaining({
+            maxFiles: '14d'
+        }));
+    });
+    it('should log to logger if initialized', async () => {
+        const dm = DisplayManager.getInstance();
+        await dm.initialize({ enabled: true, level: 'info', retention: '14d' });
+        dm.log('test message', { level: 'info' });
+        expect(mocks.loggerLog).toHaveBeenCalledWith(expect.objectContaining({
+            level: 'info',
+            message: 'test message'
+        }));
+    });
+});

package/dist/runtime/__tests__/manual_start_verify.js

@@ -0,0 +1,42 @@
+import { Agent } from '../agent.js';
+import chalk from 'chalk';
+const start = Date.now();
+console.log(chalk.blue('Running Manual Start Verification...'));
+const mockConfig = {
+    agent: { name: 'TestAgent', personality: 'Robot' },
+    llm: { provider: 'openai', model: 'gpt-3.5-turbo', temperature: 0.1, api_key: 'sk-mock-key' },
+    channels: {
+        telegram: { enabled: false, allowedUsers: [] },
+        discord: { enabled: false }
+    },
+    ui: { enabled: false, port: 3333 },
+    logging: { enabled: false, level: 'info', retention: '1d' }
+};
+const run = async () => {
+    try {
+        console.log(chalk.gray('1. Instantiating Agent...'));
+        const agent = new Agent(mockConfig);
+        console.log(chalk.gray('2. Initializing Agent...'));
+        await agent.initialize();
+        const duration = (Date.now() - start) / 1000;
+        console.log(chalk.green(`✓ Agent initialized successfully in ${duration}s`));
+        if (duration > 5) {
+            console.log(chalk.red(`✗ Startup took too long (> 5s)`));
+            process.exit(1);
+        }
+        console.log(chalk.gray('3. Testing Initialization Check...'));
+        try {
+            await agent.chat('Hello');
+            // This might fail if using real network, but we just want to ensure it tries
+        }
+        catch (e) {
+            console.log(chalk.yellow(`Chat check: ${e.message}`));
+            // Expected to fail with mock key on real network, that's fine for "Start" verification
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Verification Failed:'), error);
+        process.exit(1);
+    }
+};
+run();

package/dist/runtime/__tests__/manual_us1.js

@@ -0,0 +1,33 @@
+import { Agent } from '../agent.js';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+// Verify environment requirements
+if (!process.env.OPENAI_API_KEY) {
+    console.error("Skipping manual test: OPENAI_API_KEY not found in environment");
+    process.exit(0);
+}
+const manualConfig = {
+    ...DEFAULT_CONFIG,
+    llm: {
+        provider: 'openai',
+        model: 'gpt-3.5-turbo',
+        temperature: 0.7,
+        api_key: process.env.OPENAI_API_KEY
+    }
+};
+async function run() {
+    console.log("Initializing Agent...");
+    const agent = new Agent(manualConfig);
+    await agent.initialize();
+    console.log("Sending message: 'Hello, are you there?'");
+    try {
+        const response = await agent.chat("Hello, are you there?");
+        console.log("Response received:");
+        console.log("---------------------------------------------------");
+        console.log(response);
+        console.log("---------------------------------------------------");
+    }
+    catch (error) {
+        console.error("Chat failed:", error);
+    }
+}
+run();

package/dist/runtime/agent.js

@@ -0,0 +1,84 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { ProviderFactory } from "./providers/factory.js";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+export class Agent {
+    provider;
+    config;
+    history;
+    display = DisplayManager.getInstance();
+    constructor(config) {
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    async initialize() {
+        if (!this.config.llm) {
+            throw new Error("LLM configuration missing in config object.");
+        }
+        // Basic validation before provider creation
+        if (!this.config.llm.provider) {
+            throw new Error("LLM provider not specified in configuration.");
+        }
+        // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
+        // to allow for Environment Variable fallback supported by LangChain.
+        try {
+            this.provider = ProviderFactory.create(this.config.llm);
+            if (!this.provider) {
+                throw new Error("Provider factory returned undefined");
+            }
+            // Initialize persistent memory with SQLite
+            this.history = new SQLiteChatMessageHistory({
+                sessionId: "default",
+            });
+        }
+        catch (err) {
+            if (err instanceof ProviderError)
+                throw err; // Re-throw known errors
+            // Wrap unknown errors
+            throw new ProviderError(this.config.llm.provider || 'unknown', err, "Agent initialization failed");
+        }
+    }
+    async chat(message) {
+        if (!this.provider) {
+            throw new Error("Agent not initialized. Call initialize() first.");
+        }
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        try {
+            this.display.log('Processing message...', { source: 'Agent' });
+            const userMessage = new HumanMessage(message);
+            const systemMessage = new SystemMessage(`You are ${this.config.agent.name}, ${this.config.agent.personality}. You are a personal dev assistent.`);
+            // Load existing history from database
+            const previousMessages = await this.history.getMessages();
+            const messages = [
+                systemMessage,
+                ...previousMessages,
+                userMessage
+            ];
+            const response = await this.provider.invoke(messages);
+            const content = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+            // Persist messages to database
+            await this.history.addMessage(userMessage);
+            await this.history.addMessage(new AIMessage(content));
+            this.display.log('Response generated.', { source: 'Agent' });
+            return content;
+        }
+        catch (err) {
+            throw new ProviderError(this.config.llm.provider, err, "Chat request failed");
+        }
+    }
+    async getHistory() {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        return await this.history.getMessages();
+    }
+    async clearMemory() {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        await this.history.clear();
+    }
+}

package/dist/runtime/display.js

@@ -0,0 +1,146 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { LOGS_DIR } from '../config/paths.js';
+export class DisplayManager {
+    static instance;
+    spinner;
+    logger;
+    constructor() {
+        this.spinner = ora();
+    }
+    static getInstance() {
+        if (!DisplayManager.instance) {
+            DisplayManager.instance = new DisplayManager();
+        }
+        return DisplayManager.instance;
+    }
+    async initialize(config) {
+        if (!config.enabled) {
+            return;
+        }
+        const { combine, timestamp, printf } = winston.format;
+        const logFormat = printf(({ level, message, timestamp, ...meta }) => {
+            const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : '';
+            return `${timestamp} [${level}] ${message} ${metaStr}`.trim();
+        });
+        this.logger = winston.createLogger({
+            level: config.level,
+            format: combine(timestamp(), logFormat),
+            transports: [
+                new DailyRotateFile({
+                    dirname: LOGS_DIR,
+                    filename: 'morpheus-%DATE%.log',
+                    datePattern: 'YYYY-MM-DD',
+                    maxFiles: config.retention,
+                }),
+            ],
+        });
+    }
+    startSpinner(text) {
+        if (this.spinner.isSpinning) {
+            if (text) {
+                this.spinner.text = text;
+            }
+            return;
+        }
+        this.spinner.start(text);
+    }
+    updateSpinner(text) {
+        if (this.spinner.isSpinning) {
+            this.spinner.text = text;
+        }
+    }
+    stopSpinner(success) {
+        if (!this.spinner.isSpinning)
+            return;
+        if (success === true) {
+            this.spinner.succeed();
+        }
+        else if (success === false) {
+            this.spinner.fail();
+        }
+        else {
+            this.spinner.stop();
+        }
+    }
+    log(message, options) {
+        const wasSpinning = this.spinner.isSpinning;
+        const previousText = this.spinner.text;
+        if (wasSpinning) {
+            this.spinner.stop();
+        }
+        let prefix = '';
+        if (options?.source) {
+            let color = chalk.blue;
+            if (options.source === 'Telegram') {
+                color = chalk.green;
+            }
+            else if (options.source === 'Agent') {
+                color = chalk.hex('#FFA500');
+            }
+            prefix = color(`[${options.source}] `);
+        }
+        let formattedMessage = message;
+        if (options?.level) {
+            switch (options.level) {
+                case 'error':
+                    formattedMessage = chalk.red(message);
+                    break;
+                case 'warning':
+                    formattedMessage = chalk.yellow(message);
+                    break;
+                case 'success':
+                    formattedMessage = chalk.green(message);
+                    break;
+                case 'info':
+                case 'debug':
+                default:
+                    formattedMessage = message;
+            }
+        }
+        // Only print debug messages if we were verbose? Or always print?
+        // Console output should probably filter debug unless debug mode is on. 
+        // But currently DisplayManager doesn't seem to hold global 'debug' state for console, 
+        // it just prints what it's told. 
+        // For now I'll assume console log logic remains matching inputs roughly.
+        // Spec doesn't strictly say suppress debug on console, but implies user value focus.
+        // 'debug' level usually shouldn't clutter console unless requested.
+        // But existing log() Implementation didn't handle 'debug' specifically before I added it to type.
+        // I'll leave console behavior as is (prints everything).
+        console.log(`${prefix}${formattedMessage}`);
+        if (this.logger) {
+            try {
+                const level = this.mapLevel(options?.level);
+                const meta = options?.meta || {};
+                if (options?.source) {
+                    meta.source = options.source;
+                }
+                this.logger.log({
+                    level,
+                    message,
+                    ...meta
+                });
+            }
+            catch (err) {
+                // Safe logging fail-safe as per T015
+                // Do not crash if file logging fails, maybe print to stderr?
+                // But if logging itself fails, maybe just ignore to keep CLI running.
+            }
+        }
+        if (wasSpinning) {
+            this.spinner.start(previousText);
+        }
+    }
+    mapLevel(level) {
+        switch (level) {
+            case 'warning': return 'warn';
+            case 'success': return 'info';
+            case 'error': return 'error';
+            case 'debug': return 'debug';
+            case 'info':
+            default: return 'info';
+        }
+    }
+}