bluera-knowledge 0.14.0 → 0.14.1

package/src/mcp/handlers/store.handler.ts

@@ -1,318 +0,0 @@
-import { rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { JobService } from '../../services/job.service.js';
-import { createStoreId } from '../../types/brands.js';
-import { spawnBackgroundWorker } from '../../workers/spawn-worker.js';
-import {
-  ListStoresArgsSchema,
-  GetStoreInfoArgsSchema,
-  CreateStoreArgsSchema,
-  IndexStoreArgsSchema,
-  DeleteStoreArgsSchema,
-} from '../schemas/index.js';
-import type {
-  ListStoresArgs,
-  GetStoreInfoArgs,
-  CreateStoreArgs,
-  IndexStoreArgs,
-  DeleteStoreArgs,
-} from '../schemas/index.js';
-import type { ToolHandler, ToolResponse } from '../types.js';
-
-/**
- * Handle list_stores requests
- *
- * Lists all knowledge stores with optional type filtering.
- */
-export const handleListStores: ToolHandler<ListStoresArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = ListStoresArgsSchema.parse(args);
-
-  const { services } = context;
-
-  const stores = await services.store.list();
-  const filtered =
-    validated.type !== undefined ? stores.filter((s) => s.type === validated.type) : stores;
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            stores: filtered.map((s) => ({
-              id: s.id,
-              name: s.name,
-              type: s.type,
-              path: 'path' in s ? s.path : undefined,
-              url: 'url' in s && s.url !== undefined ? s.url : undefined,
-              description: s.description,
-              createdAt: s.createdAt.toISOString(),
-            })),
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-};
-
-/**
- * Handle get_store_info requests
- *
- * Retrieves detailed information about a specific store.
- */
-export const handleGetStoreInfo: ToolHandler<GetStoreInfoArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = GetStoreInfoArgsSchema.parse(args);
-
-  const { services } = context;
-
-  const store = await services.store.getByIdOrName(createStoreId(validated.store));
-
-  if (store === undefined) {
-    throw new Error(`Store not found: ${validated.store}`);
-  }
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            id: store.id,
-            name: store.name,
-            type: store.type,
-            path: 'path' in store ? store.path : undefined,
-            url: 'url' in store && store.url !== undefined ? store.url : undefined,
-            branch: 'branch' in store ? store.branch : undefined,
-            description: store.description,
-            status: store.status,
-            createdAt: store.createdAt.toISOString(),
-            updatedAt: store.updatedAt.toISOString(),
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-};
-
-/**
- * Handle create_store requests
- *
- * Creates a new knowledge store and starts background indexing.
- * Returns store info and job ID for tracking progress.
- */
-export const handleCreateStore: ToolHandler<CreateStoreArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = CreateStoreArgsSchema.parse(args);
-
-  const { services, options } = context;
-
-  // Determine if source is a URL or path
-  const isUrl =
-    validated.source.startsWith('http://') ||
-    validated.source.startsWith('https://') ||
-    validated.source.startsWith('git@');
-
-  const result = await services.store.create({
-    name: validated.name,
-    type: validated.type,
-    ...(isUrl ? { url: validated.source } : { path: validated.source }),
-    ...(validated.branch !== undefined ? { branch: validated.branch } : {}),
-    ...(validated.description !== undefined ? { description: validated.description } : {}),
-  });
-
-  if (!result.success) {
-    throw new Error(result.error.message);
-  }
-
-  // Create background job for indexing
-  const jobService = new JobService(options.dataDir);
-  const jobDetails: Record<string, unknown> = {
-    storeName: result.data.name,
-    storeId: result.data.id,
-  };
-  if (isUrl) {
-    jobDetails['url'] = validated.source;
-  }
-  if ('path' in result.data && result.data.path) {
-    jobDetails['path'] = result.data.path;
-  }
-  const job = jobService.createJob({
-    type: validated.type === 'repo' && isUrl ? 'clone' : 'index',
-    details: jobDetails,
-    message: `Indexing ${result.data.name}...`,
-  });
-
-  // Spawn background worker
-  spawnBackgroundWorker(job.id, options.dataDir);
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            store: {
-              id: result.data.id,
-              name: result.data.name,
-              type: result.data.type,
-              path: 'path' in result.data ? result.data.path : undefined,
-            },
-            job: {
-              id: job.id,
-              status: job.status,
-              message: job.message,
-            },
-            message: `Store created. Indexing started in background (Job ID: ${job.id})`,
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-};
-
-/**
- * Handle index_store requests
- *
- * Re-indexes an existing store in the background.
- * Returns job ID for tracking progress.
- */
-export const handleIndexStore: ToolHandler<IndexStoreArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = IndexStoreArgsSchema.parse(args);
-
-  const { services, options } = context;
-
-  const store = await services.store.getByIdOrName(createStoreId(validated.store));
-
-  if (store === undefined) {
-    throw new Error(`Store not found: ${validated.store}`);
-  }
-
-  // Create background job for indexing
-  const jobService = new JobService(options.dataDir);
-  const jobDetails: Record<string, unknown> = {
-    storeName: store.name,
-    storeId: store.id,
-  };
-  if ('path' in store && store.path) {
-    jobDetails['path'] = store.path;
-  }
-  const job = jobService.createJob({
-    type: 'index',
-    details: jobDetails,
-    message: `Re-indexing ${store.name}...`,
-  });
-
-  // Spawn background worker
-  spawnBackgroundWorker(job.id, options.dataDir);
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            store: {
-              id: store.id,
-              name: store.name,
-            },
-            job: {
-              id: job.id,
-              status: job.status,
-              message: job.message,
-            },
-            message: `Indexing started in background (Job ID: ${job.id})`,
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-};
-
-/**
- * Handle delete_store requests
- *
- * Deletes a store and all associated data:
- * - Removes from store registry
- * - Drops LanceDB table
- * - For repo stores with URL, removes cloned files
- */
-export const handleDeleteStore: ToolHandler<DeleteStoreArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = DeleteStoreArgsSchema.parse(args);
-
-  const { services, options } = context;
-
-  const store = await services.store.getByIdOrName(createStoreId(validated.store));
-
-  if (store === undefined) {
-    throw new Error(`Store not found: ${validated.store}`);
-  }
-
-  // Delete LanceDB table first (so searches don't return results for deleted store)
-  await services.lance.deleteStore(store.id);
-
-  // Delete code graph file
-  await services.codeGraph.deleteGraph(store.id);
-
-  // For repo stores cloned from URL, remove the cloned directory
-  if (store.type === 'repo' && 'url' in store && store.url !== undefined) {
-    if (options.dataDir === undefined) {
-      throw new Error('dataDir is required to delete cloned repository files');
-    }
-    const repoPath = join(options.dataDir, 'repos', store.id);
-    await rm(repoPath, { recursive: true, force: true });
-  }
-
-  // Delete from registry last
-  const result = await services.store.delete(store.id);
-  if (!result.success) {
-    throw new Error(result.error.message);
-  }
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            deleted: true,
-            store: {
-              id: store.id,
-              name: store.name,
-              type: store.type,
-            },
-            message: `Successfully deleted store: ${store.name}`,
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  };
-};

package/src/mcp/handlers/uninstall.handler.test.ts

@@ -1,194 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { handleUninstall } from './uninstall.handler.js';
-import type { HandlerContext } from '../types.js';
-import type { UninstallArgs } from './uninstall.handler.js';
-
-// Mock os module to control homedir for testing global data deletion
-vi.mock('node:os', async () => {
-  const actual = await vi.importActual<typeof import('node:os')>('node:os');
-  return {
-    ...actual,
-    homedir: vi.fn(() => actual.homedir()),
-  };
-});
-
-describe('uninstall.handler', () => {
-  let tempDir: string;
-  let projectRoot: string;
-  let mockContext: HandlerContext;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'uninstall-handler-test-'));
-    projectRoot = tempDir;
-
-    // Create minimal mock context - uninstall handler doesn't use services
-    mockContext = {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      services: {} as HandlerContext['services'],
-      options: { projectRoot },
-    };
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-    vi.restoreAllMocks();
-  });
-
-  describe('handleUninstall', () => {
-    it('should delete project data when it exists', async () => {
-      // Create project data structure
-      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-      const dataDir = join(bkDir, 'data');
-      mkdirSync(dataDir, { recursive: true });
-      writeFileSync(join(bkDir, 'config.json'), '{}');
-      writeFileSync(join(dataDir, 'stores.json'), '[]');
-
-      const args: UninstallArgs = {};
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify deletion
-      expect(existsSync(join(bkDir, 'data'))).toBe(false);
-      expect(existsSync(join(bkDir, 'config.json'))).toBe(false);
-
-      // Verify response
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('Deleted:');
-      expect(result.content[0].text).toContain('plugin cache');
-    });
-
-    it('should preserve stores.config.json by default', async () => {
-      // Create project data structure
-      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-      const dataDir = join(bkDir, 'data');
-      mkdirSync(dataDir, { recursive: true });
-      writeFileSync(join(bkDir, 'config.json'), '{}');
-      writeFileSync(join(bkDir, 'stores.config.json'), '{"stores":[]}');
-      writeFileSync(join(dataDir, 'stores.json'), '[]');
-
-      const args: UninstallArgs = { keepDefinitions: true };
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify stores.config.json is preserved
-      expect(existsSync(join(bkDir, 'stores.config.json'))).toBe(true);
-      expect(existsSync(join(bkDir, 'data'))).toBe(false);
-      expect(existsSync(join(bkDir, 'config.json'))).toBe(false);
-
-      // Verify response mentions preserved files
-      expect(result.content[0].text).toContain('Preserved:');
-      expect(result.content[0].text).toContain('stores.config.json');
-    });
-
-    it('should delete stores.config.json when keepDefinitions is false', async () => {
-      // Create project data structure
-      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-      mkdirSync(bkDir, { recursive: true });
-      writeFileSync(join(bkDir, 'stores.config.json'), '{"stores":[]}');
-
-      const args: UninstallArgs = { keepDefinitions: false };
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify entire directory is gone
-      expect(existsSync(bkDir)).toBe(false);
-
-      // Verify response
-      expect(result.content[0].text).toContain('Deleted:');
-      expect(result.content[0].text).not.toContain('Preserved:');
-    });
-
-    it('should handle missing project data gracefully', async () => {
-      const args: UninstallArgs = {};
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify response indicates nothing to delete
-      expect(result.content[0].text).toContain('No data found to delete');
-      expect(result.content[0].text).toContain('plugin cache');
-    });
-
-    it('should always include plugin cache instructions', async () => {
-      const args: UninstallArgs = {};
-      const result = await handleUninstall(args, mockContext);
-
-      expect(result.content[0].text).toContain('To fully uninstall (clear plugin cache):');
-      expect(result.content[0].text).toContain('~/.claude/plugins/cache/bluera-knowledge-*');
-    });
-
-    it('should mention venv is cleaned with plugin cache', async () => {
-      const args: UninstallArgs = {};
-      const result = await handleUninstall(args, mockContext);
-
-      expect(result.content[0].text).toContain('Python venv');
-      expect(result.content[0].text).toContain('all dependencies');
-    });
-
-    it('should handle subdirectories in data folder', async () => {
-      // Create nested structure
-      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-      const reposDir = join(bkDir, 'data', 'repos', 'test-repo');
-      mkdirSync(reposDir, { recursive: true });
-      writeFileSync(join(reposDir, 'file.txt'), 'test');
-
-      const args: UninstallArgs = {};
-      await handleUninstall(args, mockContext);
-
-      // Verify everything is deleted
-      expect(existsSync(join(bkDir, 'data'))).toBe(false);
-    });
-
-    it('should delete global data when global flag is true', async () => {
-      // Mock homedir to return our temp directory
-      const { homedir } = await import('node:os');
-      vi.mocked(homedir).mockReturnValue(tempDir);
-
-      // Create fake global data directory
-      const globalDir = join(tempDir, '.local', 'share', 'bluera-knowledge');
-      mkdirSync(globalDir, { recursive: true });
-      writeFileSync(join(globalDir, 'jobs.json'), '[]');
-
-      const args: UninstallArgs = { global: true };
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify global data was deleted
-      expect(existsSync(globalDir)).toBe(false);
-      expect(result.content[0].text).toContain('Deleted:');
-      expect(result.content[0].text).toContain('.local/share/bluera-knowledge');
-    });
-
-    it('should handle global flag when global data does not exist', async () => {
-      // Mock homedir to return our temp directory (no global data exists)
-      const { homedir } = await import('node:os');
-      vi.mocked(homedir).mockReturnValue(tempDir);
-
-      const args: UninstallArgs = { global: true };
-      const result = await handleUninstall(args, mockContext);
-
-      // The handler should still complete without errors
-      expect(result.content[0].text).toContain('plugin cache');
-    });
-
-    it('should report global data deletion in result', async () => {
-      // Mock homedir to return our temp directory
-      const { homedir } = await import('node:os');
-      vi.mocked(homedir).mockReturnValue(tempDir);
-
-      // Create both project and global data
-      const bkDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-      mkdirSync(bkDir, { recursive: true });
-      writeFileSync(join(bkDir, 'config.json'), '{}');
-
-      const globalDir = join(tempDir, '.local', 'share', 'bluera-knowledge');
-      mkdirSync(globalDir, { recursive: true });
-      writeFileSync(join(globalDir, 'jobs.json'), '[]');
-
-      const args: UninstallArgs = { global: true, keepDefinitions: false };
-      const result = await handleUninstall(args, mockContext);
-
-      // Verify both were deleted
-      expect(existsSync(bkDir)).toBe(false);
-      expect(existsSync(globalDir)).toBe(false);
-      expect(result.content[0].text).toContain('Deleted:');
-    });
-  });
-});

package/src/mcp/handlers/uninstall.handler.ts

@@ -1,142 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readdir, rm } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { createLogger } from '../../logging/index.js';
-import type { ToolHandler, ToolResponse } from '../types.js';
-
-const logger = createLogger('uninstall-handler');
-
-/**
- * Arguments for the uninstall handler
- */
-export interface UninstallArgs {
-  /** Also remove global data (~/.local/share/bluera-knowledge) */
-  global?: boolean;
-  /** Keep stores.config.json (default: true) */
-  keepDefinitions?: boolean;
-}
-
-/**
- * Handle uninstall requests
- *
- * Removes Bluera Knowledge data from the project and optionally global data.
- * Always prints instructions for clearing the plugin cache.
- */
-export const handleUninstall: ToolHandler<UninstallArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  const { global: includeGlobal = false, keepDefinitions = true } = args;
-  const deleted: string[] = [];
-  const kept: string[] = [];
-  const errors: string[] = [];
-
-  // Get project root from context or options
-  const projectRoot = context.options.projectRoot ?? process.cwd();
-  const projectDataDir = join(projectRoot, '.bluera', 'bluera-knowledge');
-
-  logger.info({ projectDataDir, includeGlobal, keepDefinitions }, 'Starting uninstall');
-
-  // Delete project data
-  if (existsSync(projectDataDir)) {
-    if (keepDefinitions) {
-      // Delete everything except stores.config.json
-      try {
-        const entries = await readdir(projectDataDir, { withFileTypes: true });
-        for (const entry of entries) {
-          const entryPath = join(projectDataDir, entry.name);
-          if (entry.name === 'stores.config.json') {
-            kept.push(entryPath);
-            continue;
-          }
-          try {
-            await rm(entryPath, { recursive: true, force: true });
-            deleted.push(entryPath);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`Failed to delete ${entryPath}: ${msg}`);
-            logger.error({ error: msg, path: entryPath }, 'Failed to delete');
-          }
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        errors.push(`Failed to read ${projectDataDir}: ${msg}`);
-        logger.error({ error: msg, path: projectDataDir }, 'Failed to read directory');
-      }
-    } else {
-      // Delete entire directory including stores.config.json
-      try {
-        await rm(projectDataDir, { recursive: true, force: true });
-        deleted.push(projectDataDir);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        errors.push(`Failed to delete ${projectDataDir}: ${msg}`);
-        logger.error({ error: msg, path: projectDataDir }, 'Failed to delete');
-      }
-    }
-  }
-
-  // Delete global data if requested
-  if (includeGlobal) {
-    const globalDir = join(homedir(), '.local', 'share', 'bluera-knowledge');
-    if (existsSync(globalDir)) {
-      try {
-        await rm(globalDir, { recursive: true, force: true });
-        deleted.push(globalDir);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        errors.push(`Failed to delete ${globalDir}: ${msg}`);
-        logger.error({ error: msg, path: globalDir }, 'Failed to delete global data');
-      }
-    }
-  }
-
-  logger.info({ deleted, kept, errors }, 'Uninstall complete');
-
-  // Build result message
-  const lines: string[] = [];
-
-  if (deleted.length > 0) {
-    lines.push('## Deleted:');
-    for (const path of deleted) {
-      lines.push(`- ${path}`);
-    }
-  } else {
-    lines.push('No data found to delete.');
-  }
-
-  if (kept.length > 0) {
-    lines.push('');
-    lines.push('## Preserved:');
-    for (const path of kept) {
-      lines.push(`- ${path}`);
-    }
-    lines.push('');
-    lines.push('_Use `keepDefinitions: false` to also remove stores.config.json_');
-  }
-
-  if (errors.length > 0) {
-    lines.push('');
-    lines.push('## Errors:');
-    for (const error of errors) {
-      lines.push(`- ${error}`);
-    }
-  }
-
-  // Always include plugin cache instructions
-  // Note: Python venv is inside plugin cache, so it gets cleaned automatically
-  lines.push('');
-  lines.push('---');
-  lines.push('');
-  lines.push('## To fully uninstall (clear plugin cache):');
-  lines.push('1. Exit Claude Code');
-  lines.push('2. Run: `rm -rf ~/.claude/plugins/cache/bluera-knowledge-*`');
-  lines.push('3. Restart Claude Code');
-  lines.push('');
-  lines.push('_This removes the plugin, Python venv, and all dependencies._');
-
-  return {
-    content: [{ type: 'text', text: lines.join('\n') }],
-  };
-};