@botmem/cli 0.10.1 → 0.11.1

package/dist/__tests__/commands.test.js

@@ -0,0 +1,821 @@
+"use strict";
+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 });
+const vitest_1 = require("vitest");
+// Mock the format module to avoid ANSI noise
+vitest_1.vi.mock('../format.js', async () => {
+    const actual = await vitest_1.vi.importActual('../format.js');
+    return {
+        ...actual,
+        // Keep real implementations — we just need the module to be importable
+    };
+});
+// Helper to create a mock client
+function createMockClient() {
+    return {
+        searchMemories: vitest_1.vi.fn().mockResolvedValue({ items: [], fallback: false }),
+        listMemories: vitest_1.vi.fn().mockResolvedValue({ items: [], total: 0 }),
+        getMemory: vitest_1.vi.fn().mockResolvedValue({
+            id: 'm1',
+            text: 'test',
+            sourceType: 'email',
+            connectorType: 'gmail',
+            eventTime: '2025-01-01',
+            importance: null,
+            factuality: null,
+            embeddingStatus: 'done',
+            entities: null,
+        }),
+        deleteMemory: vitest_1.vi.fn().mockResolvedValue({ ok: true }),
+        getMemoryStats: vitest_1.vi.fn().mockResolvedValue({
+            total: 100,
+            bySource: {},
+            byConnector: {},
+            byFactuality: {},
+        }),
+        listContacts: vitest_1.vi.fn().mockResolvedValue({ items: [], total: 0 }),
+        searchContacts: vitest_1.vi.fn().mockResolvedValue([]),
+        getContact: vitest_1.vi.fn().mockResolvedValue({
+            id: 'c1',
+            displayName: 'Test',
+            identifiers: [],
+        }),
+        getContactMemories: vitest_1.vi.fn().mockResolvedValue([]),
+        agentAsk: vitest_1.vi.fn().mockResolvedValue({ answer: 'test answer' }),
+        agentSummarize: vitest_1.vi.fn().mockResolvedValue({ summary: 'test summary' }),
+        agentContext: vitest_1.vi.fn().mockResolvedValue({ contact: { displayName: 'Test' } }),
+        listJobs: vitest_1.vi.fn().mockResolvedValue({ jobs: [] }),
+        triggerSync: vitest_1.vi.fn().mockResolvedValue({ job: { id: 'j1' } }),
+        retryFailedJobs: vitest_1.vi.fn().mockResolvedValue({ ok: true, retried: 2 }),
+        retryFailedMemories: vitest_1.vi.fn().mockResolvedValue({ enqueued: 3, total: 5 }),
+        listAccounts: vitest_1.vi.fn().mockResolvedValue({ accounts: [] }),
+        getVersion: vitest_1.vi.fn().mockResolvedValue({
+            buildTime: '2025-01-01',
+            gitHash: 'abc',
+            uptime: 3600,
+        }),
+        getTimeline: vitest_1.vi.fn().mockResolvedValue({ items: [], total: 0 }),
+        getRelated: vitest_1.vi.fn().mockResolvedValue({ items: [], source: null }),
+        searchEntities: vitest_1.vi.fn().mockResolvedValue({ entities: [], total: 0 }),
+        getEntityGraph: vitest_1.vi.fn().mockResolvedValue({
+            entity: 'Test',
+            memories: [],
+            relatedEntities: [],
+            contacts: [],
+            memoryCount: 0,
+        }),
+        listMemoryBanks: vitest_1.vi.fn().mockResolvedValue([]),
+        createMemoryBank: vitest_1.vi.fn().mockResolvedValue({ id: 'b1', name: 'Work' }),
+        renameMemoryBank: vitest_1.vi.fn().mockResolvedValue({ id: 'b1', name: 'Personal' }),
+        deleteMemoryBank: vitest_1.vi.fn().mockResolvedValue(undefined),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let logSpy;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let errorSpy;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let exitSpy;
+/** Helper to extract a logged string from spy calls (avoids `unknown` type errors). */
+function logged(spy, call = 0, arg = 0) {
+    return spy.mock.calls[call][arg];
+}
+(0, vitest_1.beforeEach)(() => {
+    logSpy = vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
+    errorSpy = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+    exitSpy = vitest_1.vi.spyOn(process, 'exit').mockImplementation((() => { }));
+});
+(0, vitest_1.afterEach)(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+});
+// --- Search ---
+(0, vitest_1.describe)('runSearch', () => {
+    let runSearch;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runSearch } = await Promise.resolve().then(() => __importStar(require('../commands/search.js'))));
+    });
+    (0, vitest_1.it)('should search with query words', async () => {
+        const client = createMockClient();
+        await runSearch(client, ['hello', 'world'], false);
+        (0, vitest_1.expect)(client.searchMemories).toHaveBeenCalledWith('hello world', undefined, undefined, undefined);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should pass filters and limit', async () => {
+        const client = createMockClient();
+        await runSearch(client, [
+            'test',
+            '--source',
+            'email',
+            '--connector',
+            'gmail',
+            '--limit',
+            '5',
+            '--memory-bank',
+            'bank-1',
+        ], false);
+        (0, vitest_1.expect)(client.searchMemories).toHaveBeenCalledWith('test', { sourceType: 'email', connectorType: 'gmail' }, 5, 'bank-1');
+    });
+    (0, vitest_1.it)('should output JSON when json=true', async () => {
+        const client = createMockClient();
+        await runSearch(client, ['test'], true);
+        const output = logged(logSpy, 0, 0);
+        (0, vitest_1.expect)(() => JSON.parse(output)).not.toThrow();
+    });
+    (0, vitest_1.it)('should exit when no query provided', async () => {
+        const client = createMockClient();
+        await runSearch(client, [], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a query'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.it)('should display resolved entities info when present', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [
+                {
+                    id: 'm1',
+                    text: 'test',
+                    sourceType: 'email',
+                    connectorType: 'gmail',
+                    eventTime: '2025-01-01',
+                    score: 0.9,
+                },
+            ],
+            fallback: false,
+            resolvedEntities: {
+                contacts: [{ id: 'c1', displayName: 'Amr' }],
+                topicWords: ['project'],
+            },
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Amr'));
+    });
+    (0, vitest_1.it)('should show no memories message when resolved entities but no results', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [],
+            fallback: false,
+            resolvedEntities: {
+                contacts: [{ id: 'c1', displayName: 'Amr' }],
+                topicWords: [],
+            },
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('No memories found'));
+    });
+    (0, vitest_1.it)('should show fallback message when fallback=true', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [
+                {
+                    id: 'm1',
+                    text: 'test',
+                    sourceType: 'email',
+                    connectorType: 'gmail',
+                    eventTime: '2025-01-01',
+                    score: 0.9,
+                },
+            ],
+            fallback: true,
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('semantically similar'));
+    });
+    (0, vitest_1.it)('should show temporal range when parsed.temporal is present', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [
+                {
+                    id: 'm1',
+                    text: 'test',
+                    sourceType: 'email',
+                    connectorType: 'gmail',
+                    eventTime: '2025-01-01',
+                    score: 0.9,
+                },
+            ],
+            fallback: false,
+            parsed: { temporal: { from: '2025-01-01', to: '2025-01-31' }, temporalFallback: false },
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Date filter'));
+    });
+    (0, vitest_1.it)('should show temporal fallback message', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [],
+            fallback: false,
+            parsed: { temporal: { from: '2025-01-01', to: '2025-01-31' }, temporalFallback: true },
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('No results for that time range'));
+    });
+    (0, vitest_1.it)('should show intent when not recall', async () => {
+        const client = createMockClient();
+        client.searchMemories.mockResolvedValue({
+            items: [],
+            fallback: false,
+            parsed: { intent: 'summarize' },
+        });
+        await runSearch(client, ['test'], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Intent: summarize'));
+    });
+    (0, vitest_1.it)('should pass --contact filter', async () => {
+        const client = createMockClient();
+        await runSearch(client, ['test', '--contact', 'c1'], false);
+        (0, vitest_1.expect)(client.searchMemories).toHaveBeenCalledWith('test', { contactId: 'c1' }, undefined, undefined);
+    });
+});
+// --- Memories ---
+(0, vitest_1.describe)('runMemories', () => {
+    let runMemories;
+    let runMemory;
+    let runStats;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runMemories, runMemory, runStats } = await Promise.resolve().then(() => __importStar(require('../commands/memories.js'))));
+    });
+    (0, vitest_1.it)('should list memories with params', async () => {
+        const client = createMockClient();
+        await runMemories(client, ['--limit', '10', '--offset', '5', '--source', 'email', '--connector', 'gmail'], false);
+        (0, vitest_1.expect)(client.listMemories).toHaveBeenCalledWith({
+            limit: 10,
+            offset: 5,
+            sourceType: 'email',
+            connectorType: 'gmail',
+        });
+    });
+    (0, vitest_1.it)('should output JSON when json=true', async () => {
+        const client = createMockClient();
+        await runMemories(client, [], true);
+        const output = logged(logSpy, 0, 0);
+        (0, vitest_1.expect)(() => JSON.parse(output)).not.toThrow();
+    });
+    (0, vitest_1.describe)('runMemory', () => {
+        (0, vitest_1.it)('should get a single memory', async () => {
+            const client = createMockClient();
+            await runMemory(client, ['m1'], false);
+            (0, vitest_1.expect)(client.getMemory).toHaveBeenCalledWith('m1');
+        });
+        (0, vitest_1.it)('should delete a memory', async () => {
+            const client = createMockClient();
+            await runMemory(client, ['m1', 'delete'], false);
+            (0, vitest_1.expect)(client.deleteMemory).toHaveBeenCalledWith('m1');
+            (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith('Memory deleted.');
+        });
+        (0, vitest_1.it)('should output JSON for delete', async () => {
+            const client = createMockClient();
+            await runMemory(client, ['m1', 'delete'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+        (0, vitest_1.it)('should error when no ID provided', async () => {
+            const client = createMockClient();
+            await runMemory(client, [], false);
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires an ID'));
+            (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+    (0, vitest_1.describe)('runStats', () => {
+        (0, vitest_1.it)('should get memory stats', async () => {
+            const client = createMockClient();
+            await runStats(client, false);
+            (0, vitest_1.expect)(client.getMemoryStats).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runStats(client, true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+    });
+});
+// --- Contacts ---
+(0, vitest_1.describe)('runContacts', () => {
+    let runContacts;
+    let runContact;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runContacts, runContact } = await Promise.resolve().then(() => __importStar(require('../commands/contacts.js'))));
+    });
+    (0, vitest_1.it)('should list contacts', async () => {
+        const client = createMockClient();
+        await runContacts(client, ['--limit', '20', '--offset', '10'], false);
+        (0, vitest_1.expect)(client.listContacts).toHaveBeenCalledWith({ limit: 20, offset: 10 });
+    });
+    (0, vitest_1.it)('should search contacts', async () => {
+        const client = createMockClient();
+        await runContacts(client, ['search', 'Amr'], false);
+        (0, vitest_1.expect)(client.searchContacts).toHaveBeenCalledWith('Amr');
+    });
+    (0, vitest_1.it)('should output JSON for list', async () => {
+        const client = createMockClient();
+        await runContacts(client, [], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should error on empty search query', async () => {
+        const client = createMockClient();
+        await runContacts(client, ['search'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a query'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.describe)('runContact', () => {
+        (0, vitest_1.it)('should get contact details', async () => {
+            const client = createMockClient();
+            await runContact(client, ['c1'], false);
+            (0, vitest_1.expect)(client.getContact).toHaveBeenCalledWith('c1');
+        });
+        (0, vitest_1.it)('should get contact memories', async () => {
+            const client = createMockClient();
+            await runContact(client, ['c1', 'memories'], false);
+            (0, vitest_1.expect)(client.getContactMemories).toHaveBeenCalledWith('c1');
+        });
+        (0, vitest_1.it)('should error when no ID', async () => {
+            const client = createMockClient();
+            await runContact(client, [], false);
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires an ID'));
+        });
+        (0, vitest_1.it)('should output JSON for contact', async () => {
+            const client = createMockClient();
+            await runContact(client, ['c1'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+        (0, vitest_1.it)('should output JSON for contact memories', async () => {
+            const client = createMockClient();
+            await runContact(client, ['c1', 'memories'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+    });
+});
+// --- Agent ---
+(0, vitest_1.describe)('runAsk', () => {
+    let runAsk;
+    let runContext;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runAsk, runContext } = await Promise.resolve().then(() => __importStar(require('../commands/agent.js'))));
+    });
+    (0, vitest_1.it)('should ask with query', async () => {
+        const client = createMockClient();
+        await runAsk(client, ['what', 'happened?'], false);
+        (0, vitest_1.expect)(client.agentAsk).toHaveBeenCalledWith('what happened?', undefined, undefined);
+    });
+    (0, vitest_1.it)('should use summarize when --summarize flag', async () => {
+        const client = createMockClient();
+        await runAsk(client, ['my', 'week', '--summarize'], false);
+        (0, vitest_1.expect)(client.agentSummarize).toHaveBeenCalledWith('my week', undefined);
+    });
+    (0, vitest_1.it)('should pass filters and limit', async () => {
+        const client = createMockClient();
+        await runAsk(client, [
+            'test',
+            '--source',
+            'email',
+            '--connector',
+            'gmail',
+            '--limit',
+            '5',
+            '--memory-bank',
+            'bank-1',
+        ], false);
+        (0, vitest_1.expect)(client.agentAsk).toHaveBeenCalledWith('test', { sourceType: 'email', connectorType: 'gmail', memoryBankId: 'bank-1' }, 5);
+    });
+    (0, vitest_1.it)('should output JSON', async () => {
+        const client = createMockClient();
+        await runAsk(client, ['test'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should error when no query', async () => {
+        const client = createMockClient();
+        await runAsk(client, [], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a query'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.describe)('runContext', () => {
+        (0, vitest_1.it)('should get context for contact', async () => {
+            const client = createMockClient();
+            await runContext(client, ['c1'], false);
+            (0, vitest_1.expect)(client.agentContext).toHaveBeenCalledWith('c1');
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runContext(client, ['c1'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+        (0, vitest_1.it)('should error when no contact ID', async () => {
+            const client = createMockClient();
+            await runContext(client, [], false);
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a contact ID'));
+            (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+});
+// --- Jobs ---
+(0, vitest_1.describe)('runJobs', () => {
+    let runJobs;
+    let runSync;
+    let runRetry;
+    let runAccounts;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runJobs, runSync, runRetry, runAccounts } = await Promise.resolve().then(() => __importStar(require('../commands/jobs.js'))));
+    });
+    (0, vitest_1.it)('should list jobs', async () => {
+        const client = createMockClient();
+        await runJobs(client, [], false);
+        (0, vitest_1.expect)(client.listJobs).toHaveBeenCalledWith(undefined);
+    });
+    (0, vitest_1.it)('should list jobs with account filter', async () => {
+        const client = createMockClient();
+        await runJobs(client, ['--account', 'acc-1'], false);
+        (0, vitest_1.expect)(client.listJobs).toHaveBeenCalledWith('acc-1');
+    });
+    (0, vitest_1.it)('should output JSON', async () => {
+        const client = createMockClient();
+        await runJobs(client, [], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.describe)('runSync', () => {
+        (0, vitest_1.it)('should trigger sync', async () => {
+            const client = createMockClient();
+            await runSync(client, ['acc-1'], false);
+            (0, vitest_1.expect)(client.triggerSync).toHaveBeenCalledWith('acc-1');
+            (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('j1'));
+        });
+        (0, vitest_1.it)('should error when no account ID', async () => {
+            const client = createMockClient();
+            await runSync(client, [], false);
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires an account ID'));
+            (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runSync(client, ['acc-1'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+    });
+    (0, vitest_1.describe)('runRetry', () => {
+        (0, vitest_1.it)('should retry failed jobs and memories', async () => {
+            const client = createMockClient();
+            await runRetry(client, false);
+            (0, vitest_1.expect)(client.retryFailedJobs).toHaveBeenCalled();
+            (0, vitest_1.expect)(client.retryFailedMemories).toHaveBeenCalled();
+            (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('2'));
+            (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('3'));
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runRetry(client, true);
+            const output = JSON.parse(logged(logSpy, 0, 0));
+            (0, vitest_1.expect)(output.jobs.retried).toBe(2);
+            (0, vitest_1.expect)(output.memories.enqueued).toBe(3);
+        });
+    });
+    (0, vitest_1.describe)('runAccounts', () => {
+        (0, vitest_1.it)('should list accounts', async () => {
+            const client = createMockClient();
+            await runAccounts(client, false);
+            (0, vitest_1.expect)(client.listAccounts).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runAccounts(client, true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+    });
+});
+// --- Timeline ---
+(0, vitest_1.describe)('runTimeline', () => {
+    let runTimeline;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runTimeline } = await Promise.resolve().then(() => __importStar(require('../commands/timeline.js'))));
+    });
+    (0, vitest_1.it)('should get timeline with params', async () => {
+        const client = createMockClient();
+        await runTimeline(client, [
+            '--from',
+            '2025-01-01',
+            '--to',
+            '2025-01-31',
+            '--query',
+            'meeting',
+            '--connector',
+            'gmail',
+            '--source',
+            'email',
+            '--limit',
+            '10',
+        ], false);
+        (0, vitest_1.expect)(client.getTimeline).toHaveBeenCalledWith({
+            from: '2025-01-01',
+            to: '2025-01-31',
+            query: 'meeting',
+            connectorType: 'gmail',
+            sourceType: 'email',
+            limit: 10,
+        });
+    });
+    (0, vitest_1.it)('should output JSON', async () => {
+        const client = createMockClient();
+        await runTimeline(client, [], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should show "no memories" message when empty', async () => {
+        const client = createMockClient();
+        await runTimeline(client, [], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('No memories'));
+    });
+    (0, vitest_1.it)('should display timeline items grouped by date', async () => {
+        const client = createMockClient();
+        client.getTimeline.mockResolvedValue({
+            items: [
+                {
+                    id: 'm1',
+                    text: 'Meeting at 10am',
+                    sourceType: 'email',
+                    connectorType: 'gmail',
+                    eventTime: '2025-06-15T10:00:00Z',
+                },
+                {
+                    id: 'm2',
+                    text: 'Lunch plans',
+                    sourceType: 'message',
+                    connectorType: 'slack',
+                    eventTime: '2025-06-15T12:00:00Z',
+                },
+            ],
+            total: 2,
+        });
+        await runTimeline(client, [], false);
+        // Should contain date headers and items
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Meeting at 10am'));
+    });
+});
+// --- Entities ---
+(0, vitest_1.describe)('runEntities', () => {
+    let runEntities;
+    let runRelated;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runEntities, runRelated } = await Promise.resolve().then(() => __importStar(require('../commands/entities.js'))));
+    });
+    (0, vitest_1.it)('should show help when no subcommand', async () => {
+        const client = createMockClient();
+        await runEntities(client, [], false);
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('entities'));
+    });
+    (0, vitest_1.it)('should search entities', async () => {
+        const client = createMockClient();
+        client.searchEntities.mockResolvedValue({
+            entities: [{ value: 'Google', type: 'organization', memoryCount: 10, connectors: ['gmail'] }],
+            total: 1,
+        });
+        await runEntities(client, ['search', 'Google', '--limit', '5', '--type', 'organization'], false);
+        (0, vitest_1.expect)(client.searchEntities).toHaveBeenCalledWith('Google', 5, 'organization');
+    });
+    (0, vitest_1.it)('should output JSON for search', async () => {
+        const client = createMockClient();
+        await runEntities(client, ['search', 'test'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should error when search has no query', async () => {
+        const client = createMockClient();
+        await runEntities(client, ['search'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a query'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.it)('should show entity graph', async () => {
+        const client = createMockClient();
+        client.getEntityGraph.mockResolvedValue({
+            entity: 'Google',
+            memories: [
+                {
+                    id: 'm1',
+                    text: 'Google meeting',
+                    sourceType: 'email',
+                    connectorType: 'gmail',
+                    eventTime: '2025-01-01',
+                },
+            ],
+            relatedEntities: [{ value: 'AWS', type: 'organization', count: 5 }],
+            contacts: [{ id: 'c1', displayName: 'Test User' }],
+            memoryCount: 10,
+        });
+        await runEntities(client, ['graph', 'Google'], false);
+        (0, vitest_1.expect)(client.getEntityGraph).toHaveBeenCalledWith('Google', undefined);
+    });
+    (0, vitest_1.it)('should output JSON for graph', async () => {
+        const client = createMockClient();
+        await runEntities(client, ['graph', 'Google'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should error on unknown subcommand', async () => {
+        const client = createMockClient();
+        await runEntities(client, ['unknown'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Unknown'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.describe)('runRelated', () => {
+        (0, vitest_1.it)('should get related memories', async () => {
+            const client = createMockClient();
+            client.getRelated.mockResolvedValue({
+                items: [
+                    {
+                        id: 'm2',
+                        text: 'Related memory',
+                        sourceType: 'email',
+                        connectorType: 'gmail',
+                        eventTime: '2025-01-01',
+                        score: 0.9,
+                        relationship: 'similar',
+                    },
+                ],
+                source: { text: 'Source memory' },
+            });
+            await runRelated(client, ['m1', '--limit', '5'], false);
+            (0, vitest_1.expect)(client.getRelated).toHaveBeenCalledWith('m1', 5);
+        });
+        (0, vitest_1.it)('should output JSON', async () => {
+            const client = createMockClient();
+            await runRelated(client, ['m1'], true);
+            (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+        });
+        (0, vitest_1.it)('should error when no memory ID', async () => {
+            const client = createMockClient();
+            await runRelated(client, [], false);
+            (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a memory ID'));
+            (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+        });
+        (0, vitest_1.it)('should show empty message when no related found', async () => {
+            const client = createMockClient();
+            await runRelated(client, ['m1'], false);
+            (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('No related'));
+        });
+    });
+});
+// --- Memory Banks ---
+(0, vitest_1.describe)('runMemoryBanks', () => {
+    let runMemoryBanks;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runMemoryBanks } = await Promise.resolve().then(() => __importStar(require('../commands/memory-banks.js'))));
+    });
+    (0, vitest_1.it)('should list memory banks', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, [], false);
+        (0, vitest_1.expect)(client.listMemoryBanks).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should create a memory bank', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['create', 'Work'], false);
+        (0, vitest_1.expect)(client.createMemoryBank).toHaveBeenCalledWith('Work');
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Work'));
+    });
+    (0, vitest_1.it)('should rename a memory bank', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['rename', 'b1', 'Personal'], false);
+        (0, vitest_1.expect)(client.renameMemoryBank).toHaveBeenCalledWith('b1', 'Personal');
+    });
+    (0, vitest_1.it)('should delete a memory bank', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['delete', 'b1'], false);
+        (0, vitest_1.expect)(client.deleteMemoryBank).toHaveBeenCalledWith('b1');
+    });
+    (0, vitest_1.it)('should output JSON for list', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, [], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should output JSON for create', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['create', 'Work'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should output JSON for rename', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['rename', 'b1', 'New'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should output JSON for delete', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['delete', 'b1'], true);
+        (0, vitest_1.expect)(() => JSON.parse(logged(logSpy, 0, 0))).not.toThrow();
+    });
+    (0, vitest_1.it)('should error when create has no name', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['create'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires a name'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.it)('should error when rename missing args', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['rename', 'b1'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('rename requires'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+    (0, vitest_1.it)('should error when delete has no id', async () => {
+        const client = createMockClient();
+        await runMemoryBanks(client, ['delete'], false);
+        (0, vitest_1.expect)(errorSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('requires an id'));
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    });
+});
+// --- Install Skill ---
+(0, vitest_1.describe)('runInstallSkill', () => {
+    let runInstallSkill;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runInstallSkill } = await Promise.resolve().then(() => __importStar(require('../commands/install-skill.js'))));
+    });
+    (0, vitest_1.it)('should create skill files in .agents and .claude directories', () => {
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        // Use a temp dir as cwd
+        const tempDir = path.join(os.tmpdir(), `botmem-skill-test-${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+        const origCwd = process.cwd();
+        process.chdir(tempDir);
+        try {
+            runInstallSkill();
+            // Check .agents skill file was created
+            const agentsSkill = path.join(tempDir, '.agents', 'skills', 'botmem-cli', 'SKILL.md');
+            (0, vitest_1.expect)(fs.existsSync(agentsSkill)).toBe(true);
+            const content = fs.readFileSync(agentsSkill, 'utf-8');
+            (0, vitest_1.expect)(content).toContain('botmem-cli');
+            // Check .claude symlink was created
+            const claudeSkill = path.join(tempDir, '.claude', 'skills', 'botmem-cli', 'SKILL.md');
+            (0, vitest_1.expect)(fs.existsSync(claudeSkill)).toBe(true);
+        }
+        finally {
+            process.chdir(origCwd);
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    (0, vitest_1.it)('should handle running twice (existing symlink)', () => {
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        const tempDir = path.join(os.tmpdir(), `botmem-skill-test2-${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+        const origCwd = process.cwd();
+        process.chdir(tempDir);
+        try {
+            runInstallSkill();
+            // Run again — should not throw
+            runInstallSkill();
+            const claudeSkill = path.join(tempDir, '.claude', 'skills', 'botmem-cli', 'SKILL.md');
+            (0, vitest_1.expect)(fs.existsSync(claudeSkill)).toBe(true);
+        }
+        finally {
+            process.chdir(origCwd);
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});
+// --- Version ---
+(0, vitest_1.describe)('runVersion', () => {
+    let runVersion;
+    (0, vitest_1.beforeEach)(async () => {
+        ({ runVersion } = await Promise.resolve().then(() => __importStar(require('../commands/version.js'))));
+    });
+    (0, vitest_1.it)('should get and display version info', async () => {
+        const client = createMockClient();
+        await runVersion(client, false);
+        (0, vitest_1.expect)(client.getVersion).toHaveBeenCalled();
+        (0, vitest_1.expect)(logSpy).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should output JSON', async () => {
+        const client = createMockClient();
+        await runVersion(client, true);
+        const output = JSON.parse(logged(logSpy, 0, 0));
+        (0, vitest_1.expect)(output.buildTime).toBe('2025-01-01');
+        (0, vitest_1.expect)(output.gitHash).toBe('abc');
+        (0, vitest_1.expect)(output.uptime).toBe(3600);
+    });
+});
+//# sourceMappingURL=commands.test.js.map