bluera-knowledge 0.9.21

package/src/cli/commands/index-cmd.ts

@@ -0,0 +1,105 @@
+import { Command } from 'commander';
+import ora, { type Ora } from 'ora';
+import { createServices, destroyServices } from '../../services/index.js';
+import type { GlobalOptions } from '../program.js';
+
+export function createIndexCommand(getOptions: () => GlobalOptions): Command {
+  const index = new Command('index')
+    .description('Scan store files, chunk text, generate embeddings, save to LanceDB')
+    .argument('<store>', 'Store ID or name')
+    .option('--force', 'Re-index all files even if unchanged')
+    .action(async (storeIdOrName: string, _options: { force?: boolean }) => {
+      const globalOpts = getOptions();
+      const services = await createServices(globalOpts.config, globalOpts.dataDir);
+      try {
+        const store = await services.store.getByIdOrName(storeIdOrName);
+
+        if (store === undefined) {
+          console.error(`Error: Store not found: ${storeIdOrName}`);
+          process.exit(3);
+        }
+
+        // Use spinner in interactive mode (not quiet, not json output)
+        const isInteractive = process.stdout.isTTY && globalOpts.quiet !== true && globalOpts.format !== 'json';
+        let spinner: Ora | undefined;
+
+        if (isInteractive) {
+          spinner = ora(`Indexing store: ${store.name}`).start();
+        } else if (globalOpts.quiet !== true && globalOpts.format !== 'json') {
+          console.log(`Indexing store: ${store.name}`);
+        }
+
+        await services.lance.initialize(store.id);
+
+        const result = await services.index.indexStore(store, (event) => {
+          if (event.type === 'progress') {
+            if (spinner) {
+              spinner.text = `Indexing: ${String(event.current)}/${String(event.total)} files - ${event.message}`;
+            }
+          }
+        });
+
+        if (result.success) {
+          if (globalOpts.format === 'json') {
+            console.log(JSON.stringify(result.data, null, 2));
+          } else {
+            const message = `Indexed ${String(result.data.documentsIndexed)} documents, ${String(result.data.chunksCreated)} chunks in ${String(result.data.timeMs)}ms`;
+            if (spinner !== undefined) {
+              spinner.succeed(message);
+            } else if (globalOpts.quiet !== true) {
+              console.log(message);
+            }
+          }
+        } else {
+          const message = `Error: ${result.error.message}`;
+          if (spinner !== undefined) {
+            spinner.fail(message);
+          } else {
+            console.error(message);
+          }
+          process.exit(4);
+        }
+      } finally {
+        await destroyServices(services);
+      }
+    });
+
+  index
+    .command('watch <store>')
+    .description('Watch store directory; re-index when files change')
+    .option('--debounce <ms>', 'Wait N ms after last change before re-indexing (default: 1000)', '1000')
+    .action(async (storeIdOrName: string, options: { debounce?: string }) => {
+      const globalOpts = getOptions();
+      const services = await createServices(globalOpts.config, globalOpts.dataDir);
+
+      const store = await services.store.getByIdOrName(storeIdOrName);
+      if (store === undefined || (store.type !== 'file' && store.type !== 'repo')) {
+        console.error(`Error: File/repo store not found: ${storeIdOrName}`);
+        process.exit(3);
+      }
+
+      const { WatchService } = await import('../../services/watch.service.js');
+      const watchService = new WatchService(services.index, services.lance);
+
+      if (globalOpts.quiet !== true) {
+        console.log(`Watching ${store.name} for changes...`);
+      }
+      await watchService.watch(store, parseInt(options.debounce ?? '1000', 10), () => {
+        if (globalOpts.quiet !== true) {
+          console.log(`Re-indexed ${store.name}`);
+        }
+      });
+
+      // Keep process alive
+      process.on('SIGINT', () => {
+        void (async (): Promise<void> => {
+          await watchService.unwatchAll();
+          process.exit(0);
+        })().catch(() => {
+          // Error during shutdown - process.exit already called
+        });
+      });
+    });
+
+  return index;
+}

package/src/cli/commands/mcp.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createMCPCommand } from './mcp.js';
+import type { GlobalOptions } from '../program.js';
+
+// Mock all dependencies
+vi.mock('../../mcp/server.js', () => ({
+  runMCPServer: vi.fn()
+}));
+
+describe('MCP Command - Execution Tests', () => {
+  const getOptions = (): GlobalOptions => ({
+    config: undefined,
+    dataDir: '/tmp/test-data',
+    quiet: false,
+    format: undefined,
+  });
+
+  beforeEach(async () => {
+    const { runMCPServer } = await import('../../mcp/server.js');
+    vi.mocked(runMCPServer).mockClear().mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('server execution', () => {
+    it('runs MCP server with default options', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const command = createMCPCommand(getOptions);
+      // Call the action directly instead of parsing argv
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalledWith({
+        dataDir: '/tmp/test-data',
+        config: undefined
+      });
+    });
+
+    it('runs MCP server with custom config', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const customGetOptions = (): GlobalOptions => ({
+        config: '/custom/config.json',
+        dataDir: '/tmp/test-data',
+        quiet: false,
+        format: undefined,
+      });
+
+      const command = createMCPCommand(customGetOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalledWith({
+        dataDir: '/tmp/test-data',
+        config: '/custom/config.json'
+      });
+    });
+
+    it('runs MCP server with custom dataDir', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const customGetOptions = (): GlobalOptions => ({
+        config: undefined,
+        dataDir: '/custom/data',
+        quiet: false,
+        format: undefined,
+      });
+
+      const command = createMCPCommand(customGetOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalledWith({
+        dataDir: '/custom/data',
+        config: undefined
+      });
+    });
+
+    it('runs MCP server with both custom config and dataDir', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const customGetOptions = (): GlobalOptions => ({
+        config: '/custom/config.json',
+        dataDir: '/custom/data',
+        quiet: false,
+        format: undefined,
+      });
+
+      const command = createMCPCommand(customGetOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalledWith({
+        dataDir: '/custom/data',
+        config: '/custom/config.json'
+      });
+    });
+  });
+
+  describe('option handling', () => {
+    it('passes undefined config when not specified', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      const callArgs = vi.mocked(runMCPServer).mock.calls[0]?.[0];
+      expect(callArgs?.config).toBeUndefined();
+    });
+
+    it('ignores quiet flag (not applicable to MCP server)', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const quietGetOptions = (): GlobalOptions => ({
+        config: undefined,
+        dataDir: '/tmp/test-data',
+        quiet: true,
+        format: undefined,
+      });
+
+      const command = createMCPCommand(quietGetOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalled();
+      const callArgs = vi.mocked(runMCPServer).mock.calls[0]?.[0];
+      expect(callArgs).not.toHaveProperty('quiet');
+    });
+
+    it('ignores format flag (not applicable to MCP server)', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const formatGetOptions = (): GlobalOptions => ({
+        config: undefined,
+        dataDir: '/tmp/test-data',
+        quiet: false,
+        format: 'json',
+      });
+
+      const command = createMCPCommand(formatGetOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalled();
+      const callArgs = vi.mocked(runMCPServer).mock.calls[0]?.[0];
+      expect(callArgs).not.toHaveProperty('format');
+    });
+  });
+
+  describe('error handling', () => {
+    it('propagates errors from runMCPServer', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const testError = new Error('MCP server failed');
+      vi.mocked(runMCPServer).mockRejectedValue(testError);
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler([])).rejects.toThrow('MCP server failed');
+    });
+
+    it('handles initialization errors', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      vi.mocked(runMCPServer).mockRejectedValue(new Error('Cannot initialize MCP server'));
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler([])).rejects.toThrow('Cannot initialize MCP server');
+    });
+
+    it('handles connection errors', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      vi.mocked(runMCPServer).mockRejectedValue(new Error('Connection failed'));
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler([])).rejects.toThrow('Connection failed');
+    });
+  });
+
+  describe('execution flow', () => {
+    it('calls runMCPServer exactly once', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(runMCPServer).toHaveBeenCalledTimes(1);
+    });
+
+    it('awaits runMCPServer before completing', async () => {
+      const { runMCPServer } = await import('../../mcp/server.js');
+
+      let serverStarted = false;
+
+      vi.mocked(runMCPServer).mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        serverStarted = true;
+      });
+
+      const command = createMCPCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(serverStarted).toBe(true);
+    });
+  });
+});

package/src/cli/commands/mcp.ts

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import type { GlobalOptions } from '../program.js';
+import { runMCPServer } from '../../mcp/server.js';
+
+export function createMCPCommand(getOptions: () => GlobalOptions): Command {
+  const mcp = new Command('mcp')
+    .description('Start MCP (Model Context Protocol) server for AI agent integration')
+    .action(async () => {
+      const opts = getOptions();
+
+      await runMCPServer({
+        dataDir: opts.dataDir,
+        config: opts.config
+      });
+    });
+
+  return mcp;
+}

package/src/cli/commands/plugin-api.test.ts

@@ -0,0 +1,313 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createAddRepoCommand,
+  createAddFolderCommand,
+  createStoresCommand,
+  createSuggestCommand,
+} from './plugin-api.js';
+import type { GlobalOptions } from '../program.js';
+
+// Mock all plugin command handlers
+vi.mock('../../plugin/commands.js', () => ({
+  handleAddRepo: vi.fn(),
+  handleAddFolder: vi.fn(),
+  handleStores: vi.fn(),
+  handleSuggest: vi.fn()
+}));
+
+describe('Plugin API Commands - Execution Tests', () => {
+  const getOptions = (): GlobalOptions => ({
+    config: undefined,
+    dataDir: '/tmp/test',
+    quiet: false,
+    format: undefined,
+  });
+
+  beforeEach(async () => {
+    const {
+      handleAddRepo,
+      handleAddFolder,
+      handleStores,
+      handleSuggest
+    } = await import('../../plugin/commands.js');
+
+    vi.mocked(handleAddRepo).mockClear().mockResolvedValue(undefined);
+    vi.mocked(handleAddFolder).mockClear().mockResolvedValue(undefined);
+    vi.mocked(handleStores).mockClear().mockResolvedValue(undefined);
+    vi.mocked(handleSuggest).mockClear().mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('add-repo command', () => {
+    it('calls handleAddRepo with url', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledWith({
+        url: 'https://github.com/user/repo.git'
+      });
+    });
+
+    it('calls handleAddRepo with url and name option', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      command.parseOptions(['--name', 'my-repo']);
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledWith({
+        url: 'https://github.com/user/repo.git',
+        name: 'my-repo'
+      });
+    });
+
+    it('calls handleAddRepo with url and branch option', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      command.parseOptions(['--branch', 'develop']);
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledWith({
+        url: 'https://github.com/user/repo.git',
+        branch: 'develop'
+      });
+    });
+
+    it('calls handleAddRepo with all options', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      command.parseOptions(['--name', 'custom-name', '--branch', 'main']);
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledWith({
+        url: 'https://github.com/user/repo.git',
+        name: 'custom-name',
+        branch: 'main'
+      });
+    });
+
+    it('handles errors from handleAddRepo', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      vi.mocked(handleAddRepo).mockRejectedValue(new Error('Clone failed'));
+
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler(['https://github.com/user/repo.git'])).rejects.toThrow('Clone failed');
+    });
+  });
+
+  describe('add-folder command', () => {
+    it('calls handleAddFolder with path', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['/path/to/folder']);
+
+      expect(handleAddFolder).toHaveBeenCalledWith({
+        path: '/path/to/folder'
+      });
+    });
+
+    it('calls handleAddFolder with path and name option', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      command.parseOptions(['--name', 'my-folder']);
+      await actionHandler(['/path/to/folder']);
+
+      expect(handleAddFolder).toHaveBeenCalledWith({
+        path: '/path/to/folder',
+        name: 'my-folder'
+      });
+    });
+
+    it('handles relative paths', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['./relative/path']);
+
+      expect(handleAddFolder).toHaveBeenCalledWith({
+        path: './relative/path'
+      });
+    });
+
+    it('handles paths with spaces', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['/path/with spaces/folder']);
+
+      expect(handleAddFolder).toHaveBeenCalledWith({
+        path: '/path/with spaces/folder'
+      });
+    });
+
+    it('handles errors from handleAddFolder', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      vi.mocked(handleAddFolder).mockRejectedValue(new Error('Path not found'));
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler(['/nonexistent'])).rejects.toThrow('Path not found');
+    });
+  });
+
+  describe('stores command', () => {
+    it('calls handleStores with no arguments', async () => {
+      const { handleStores } = await import('../../plugin/commands.js');
+
+      const command = createStoresCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleStores).toHaveBeenCalledWith();
+    });
+
+    it('calls handleStores exactly once', async () => {
+      const { handleStores } = await import('../../plugin/commands.js');
+
+      const command = createStoresCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleStores).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles errors from handleStores', async () => {
+      const { handleStores } = await import('../../plugin/commands.js');
+
+      vi.mocked(handleStores).mockRejectedValue(new Error('Database error'));
+
+      const command = createStoresCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler([])).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('suggest command', () => {
+    it('calls handleSuggest with no arguments', async () => {
+      const { handleSuggest } = await import('../../plugin/commands.js');
+
+      const command = createSuggestCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleSuggest).toHaveBeenCalledWith();
+    });
+
+    it('calls handleSuggest exactly once', async () => {
+      const { handleSuggest } = await import('../../plugin/commands.js');
+
+      const command = createSuggestCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleSuggest).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles errors from handleSuggest', async () => {
+      const { handleSuggest } = await import('../../plugin/commands.js');
+
+      vi.mocked(handleSuggest).mockRejectedValue(new Error('Analysis failed'));
+
+      const command = createSuggestCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+
+      await expect(actionHandler([])).rejects.toThrow('Analysis failed');
+    });
+  });
+
+  describe('command independence', () => {
+    it('add-repo does not affect other commands', async () => {
+      const { handleAddRepo, handleAddFolder } = await import('../../plugin/commands.js');
+
+      const addRepoCmd = createAddRepoCommand(getOptions);
+      const actionHandler = (addRepoCmd as any)._actionHandler;
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledTimes(1);
+      expect(handleAddFolder).not.toHaveBeenCalled();
+    });
+
+    it('add-folder does not affect other commands', async () => {
+      const { handleAddFolder, handleStores } = await import('../../plugin/commands.js');
+
+      const addFolderCmd = createAddFolderCommand(getOptions);
+      const actionHandler = (addFolderCmd as any)._actionHandler;
+      await actionHandler(['/path']);
+
+      expect(handleAddFolder).toHaveBeenCalledTimes(1);
+      expect(handleStores).not.toHaveBeenCalled();
+    });
+
+    it('stores command does not affect other commands', async () => {
+      const { handleStores, handleSuggest } = await import('../../plugin/commands.js');
+
+      const storesCmd = createStoresCommand(getOptions);
+      const actionHandler = (storesCmd as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleStores).toHaveBeenCalledTimes(1);
+      expect(handleSuggest).not.toHaveBeenCalled();
+    });
+
+    it('suggest command does not affect other commands', async () => {
+      const { handleSuggest, handleAddRepo } = await import('../../plugin/commands.js');
+
+      const suggestCmd = createSuggestCommand(getOptions);
+      const actionHandler = (suggestCmd as any)._actionHandler;
+      await actionHandler([]);
+
+      expect(handleSuggest).toHaveBeenCalledTimes(1);
+      expect(handleAddRepo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('global options handling', () => {
+    it('add-repo ignores global options', async () => {
+      const { handleAddRepo } = await import('../../plugin/commands.js');
+
+      // Global options should not be passed to handlers
+      const command = createAddRepoCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['https://github.com/user/repo.git']);
+
+      expect(handleAddRepo).toHaveBeenCalledWith({
+        url: 'https://github.com/user/repo.git'
+      });
+    });
+
+    it('add-folder ignores global options', async () => {
+      const { handleAddFolder } = await import('../../plugin/commands.js');
+
+      const command = createAddFolderCommand(getOptions);
+      const actionHandler = (command as any)._actionHandler;
+      await actionHandler(['/path']);
+
+      expect(handleAddFolder).toHaveBeenCalledWith({
+        path: '/path'
+      });
+    });
+  });
+});