bluera-knowledge 0.9.43 → 0.10.1

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

@@ -0,0 +1,283 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
+import { rm, mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { syncCommands, handleStoresSync } from './sync.commands.js';
+import { StoreService } from '../../services/store.service.js';
+import { StoreDefinitionService } from '../../services/store-definition.service.js';
+import type { HandlerContext } from '../types.js';
+import type { ServiceContainer } from '../../services/index.js';
+import type { StoreDefinitionsConfig } from '../../types/store-definition.js';
+
+/**
+ * Create a minimal mock service container for testing
+ */
+function createMockServices(storeService: StoreService): ServiceContainer {
+  return {
+    store: storeService,
+    // Other services not needed for sync tests
+    config: {} as ServiceContainer['config'],
+    search: {} as ServiceContainer['search'],
+    index: {} as ServiceContainer['index'],
+    lance: {} as ServiceContainer['lance'],
+    embeddings: {} as ServiceContainer['embeddings'],
+    codeGraph: {} as ServiceContainer['codeGraph'],
+    pythonBridge: {} as ServiceContainer['pythonBridge'],
+  };
+}
+
+describe('sync.commands', () => {
+  describe('command definition', () => {
+    it('exports stores:sync command', () => {
+      const syncCmd = syncCommands.find((c) => c.name === 'stores:sync');
+      expect(syncCmd).toBeDefined();
+      expect(syncCmd?.description).toContain('Sync');
+    });
+
+    it('has correct args schema', () => {
+      const syncCmd = syncCommands.find((c) => c.name === 'stores:sync');
+      expect(syncCmd?.argsSchema).toBeDefined();
+
+      // Valid empty args
+      const result1 = syncCmd?.argsSchema?.safeParse({});
+      expect(result1?.success).toBe(true);
+
+      // Valid with options
+      const result2 = syncCmd?.argsSchema?.safeParse({
+        reindex: true,
+        prune: true,
+        dryRun: true,
+      });
+      expect(result2?.success).toBe(true);
+    });
+  });
+
+  describe('handleStoresSync', () => {
+    let projectRoot: string;
+    let dataDir: string;
+    let storeService: StoreService;
+    let defService: StoreDefinitionService;
+    let context: HandlerContext;
+
+    beforeEach(async () => {
+      projectRoot = await mkdtemp(join(tmpdir(), 'sync-test-'));
+      dataDir = join(projectRoot, '.bluera/bluera-knowledge/data');
+      defService = new StoreDefinitionService(projectRoot);
+      storeService = new StoreService(dataDir, { definitionService: defService });
+      await storeService.initialize();
+
+      context = {
+        services: createMockServices(storeService),
+        options: { projectRoot },
+      };
+    });
+
+    afterEach(async () => {
+      await rm(projectRoot, { recursive: true, force: true });
+    });
+
+    describe('creates missing stores', () => {
+      it('creates file store from definition', async () => {
+        // Create a directory to reference
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Add definition manually (simulating config from git)
+        await defService.addDefinition({
+          type: 'file',
+          name: 'my-docs',
+          path: './docs',
+          description: 'Documentation',
+        });
+
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.created).toContain('my-docs');
+        expect(response.skipped).toHaveLength(0);
+        expect(response.failed).toHaveLength(0);
+
+        // Verify store was created
+        const store = await storeService.getByName('my-docs');
+        expect(store).toBeDefined();
+        expect(store?.type).toBe('file');
+      });
+
+      it('creates web store from definition', async () => {
+        // Add web store definition
+        await defService.addDefinition({
+          type: 'web',
+          name: 'api-docs',
+          url: 'https://example.com/docs',
+          depth: 2,
+        });
+
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.created).toContain('api-docs');
+
+        const store = await storeService.getByName('api-docs');
+        expect(store).toBeDefined();
+        expect(store?.type).toBe('web');
+      });
+    });
+
+    describe('skips existing stores', () => {
+      it('skips store that already exists', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Create store first (this auto-adds the definition via the integration)
+        await storeService.create({
+          name: 'existing-docs',
+          type: 'file',
+          path: docsDir,
+        });
+
+        // Definition was auto-added, so sync should skip this store
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.skipped).toContain('existing-docs');
+        expect(response.created).toHaveLength(0);
+      });
+    });
+
+    describe('reports orphans', () => {
+      it('reports stores not in definitions', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Create store without definition (using skipDefinitionSync)
+        await storeService.create(
+          {
+            name: 'orphan-store',
+            type: 'file',
+            path: docsDir,
+          },
+          { skipDefinitionSync: true }
+        );
+
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.orphans).toContain('orphan-store');
+      });
+    });
+
+    describe('dry run mode', () => {
+      it('does not create stores in dry run mode', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        await defService.addDefinition({
+          type: 'file',
+          name: 'dry-run-store',
+          path: './docs',
+        });
+
+        const result = await handleStoresSync({ dryRun: true }, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.dryRun).toBe(true);
+        expect(response.wouldCreate).toContain('dry-run-store');
+
+        // Store should NOT exist
+        const store = await storeService.getByName('dry-run-store');
+        expect(store).toBeUndefined();
+      });
+    });
+
+    describe('prune mode', () => {
+      it('removes orphan stores when prune is true', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        // Create orphan store
+        await storeService.create(
+          {
+            name: 'to-prune',
+            type: 'file',
+            path: docsDir,
+          },
+          { skipDefinitionSync: true }
+        );
+
+        const result = await handleStoresSync({ prune: true }, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.pruned).toContain('to-prune');
+
+        // Store should be deleted
+        const store = await storeService.getByName('to-prune');
+        expect(store).toBeUndefined();
+      });
+
+      it('does not prune in dry run mode', async () => {
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+
+        await storeService.create(
+          {
+            name: 'keep-me',
+            type: 'file',
+            path: docsDir,
+          },
+          { skipDefinitionSync: true }
+        );
+
+        const result = await handleStoresSync({ prune: true, dryRun: true }, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.wouldPrune).toContain('keep-me');
+
+        // Store should still exist
+        const store = await storeService.getByName('keep-me');
+        expect(store).toBeDefined();
+      });
+    });
+
+    describe('error handling', () => {
+      it('continues on error and reports failures', async () => {
+        // Add definition for non-existent directory
+        await defService.addDefinition({
+          type: 'file',
+          name: 'bad-store',
+          path: './nonexistent',
+        });
+
+        // Also add a valid definition
+        const docsDir = join(projectRoot, 'docs');
+        await mkdir(docsDir, { recursive: true });
+        await defService.addDefinition({
+          type: 'file',
+          name: 'good-store',
+          path: './docs',
+        });
+
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        // Should have one failure and one success
+        expect(response.failed).toHaveLength(1);
+        expect(response.failed[0].name).toBe('bad-store');
+        expect(response.failed[0].error).toBeDefined();
+        expect(response.created).toContain('good-store');
+      });
+    });
+
+    describe('empty config', () => {
+      it('handles empty definitions gracefully', async () => {
+        const result = await handleStoresSync({}, context);
+        const response = JSON.parse(result.content[0].text);
+
+        expect(response.created).toHaveLength(0);
+        expect(response.skipped).toHaveLength(0);
+        expect(response.failed).toHaveLength(0);
+        expect(response.orphans).toHaveLength(0);
+      });
+    });
+  });
+});

package/src/mcp/commands/sync.commands.ts

@@ -0,0 +1,233 @@
+import { z } from 'zod';
+import { StoreDefinitionService } from '../../services/store-definition.service.js';
+import {
+  isFileStoreDefinition,
+  isRepoStoreDefinition,
+  isWebStoreDefinition,
+} from '../../types/store-definition.js';
+import type { CommandDefinition } from './registry.js';
+import type { StoreDefinition } from '../../types/store-definition.js';
+import type { HandlerContext, ToolResponse } from '../types.js';
+
+/**
+ * Arguments for stores:sync command
+ */
+export interface SyncStoresArgs {
+  reindex?: boolean;
+  prune?: boolean;
+  dryRun?: boolean;
+}
+
+/**
+ * Result of a sync operation
+ */
+interface SyncResult {
+  created: string[];
+  skipped: string[];
+  failed: Array<{ name: string; error: string }>;
+  orphans: string[];
+  pruned?: string[];
+  dryRun?: boolean;
+  wouldCreate?: string[];
+  wouldPrune?: string[];
+}
+
+/**
+ * Handle stores:sync command
+ *
+ * Syncs stores from definitions config:
+ * - Creates missing stores from definitions
+ * - Reports stores not in definitions (orphans)
+ * - Optionally prunes orphan stores
+ * - Optionally re-indexes existing stores
+ */
+export async function handleStoresSync(
+  args: SyncStoresArgs,
+  context: HandlerContext
+): Promise<ToolResponse> {
+  const { services, options } = context;
+  const projectRoot = options.projectRoot;
+
+  if (projectRoot === undefined) {
+    throw new Error('Project root is required for stores:sync');
+  }
+
+  const defService = new StoreDefinitionService(projectRoot);
+  const config = await defService.load();
+
+  const result: SyncResult = {
+    created: [],
+    skipped: [],
+    failed: [],
+    orphans: [],
+  };
+
+  if (args.dryRun === true) {
+    result.dryRun = true;
+    result.wouldCreate = [];
+    result.wouldPrune = [];
+  }
+
+  // Get existing stores
+  const existingStores = await services.store.list();
+  const existingNames = new Set(existingStores.map((s) => s.name));
+
+  // Process each definition
+  for (const def of config.stores) {
+    if (existingNames.has(def.name)) {
+      result.skipped.push(def.name);
+      continue;
+    }
+
+    if (args.dryRun === true) {
+      result.wouldCreate?.push(def.name);
+      continue;
+    }
+
+    // Try to create the store
+    const createResult = await createStoreFromDefinition(def, defService, services, context);
+    if (createResult.success) {
+      result.created.push(def.name);
+    } else {
+      result.failed.push({ name: def.name, error: createResult.error });
+    }
+  }
+
+  // Find orphans (stores not in definitions)
+  const definedNames = new Set(config.stores.map((d) => d.name));
+  for (const store of existingStores) {
+    if (!definedNames.has(store.name)) {
+      result.orphans.push(store.name);
+    }
+  }
+
+  // Prune orphans if requested
+  if (args.prune === true && result.orphans.length > 0) {
+    if (args.dryRun === true) {
+      result.wouldPrune = [...result.orphans];
+    } else {
+      result.pruned = [];
+      for (const orphanName of result.orphans) {
+        const store = await services.store.getByName(orphanName);
+        if (store !== undefined) {
+          const deleteResult = await services.store.delete(store.id, { skipDefinitionSync: true });
+          if (deleteResult.success) {
+            result.pruned.push(orphanName);
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(result, null, 2),
+      },
+    ],
+  };
+}
+
+/**
+ * Create a store from a definition
+ */
+async function createStoreFromDefinition(
+  def: StoreDefinition,
+  defService: StoreDefinitionService,
+  services: HandlerContext['services'],
+  _context: HandlerContext
+): Promise<{ success: true } | { success: false; error: string }> {
+  try {
+    if (isFileStoreDefinition(def)) {
+      // Resolve path relative to project root
+      const resolvedPath = defService.resolvePath(def.path);
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: 'file',
+          path: resolvedPath,
+          description: def.description,
+          tags: def.tags,
+        },
+        { skipDefinitionSync: true } // Don't re-add to definitions
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+
+    if (isRepoStoreDefinition(def)) {
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: 'repo',
+          url: def.url,
+          branch: def.branch,
+          depth: def.depth,
+          description: def.description,
+          tags: def.tags,
+        },
+        { skipDefinitionSync: true }
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+
+    if (isWebStoreDefinition(def)) {
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: 'web',
+          url: def.url,
+          depth: def.depth,
+          description: def.description,
+          tags: def.tags,
+        },
+        { skipDefinitionSync: true }
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+
+    return { success: false, error: 'Unknown store definition type' };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Sync commands for the execute meta-tool
+ */
+export const syncCommands: CommandDefinition[] = [
+  {
+    name: 'stores:sync',
+    description: 'Sync stores from definitions config (bootstrap on fresh clone)',
+    argsSchema: z.object({
+      reindex: z.boolean().optional().describe('Re-index existing stores after sync'),
+      prune: z.boolean().optional().describe('Remove stores not in definitions'),
+      dryRun: z.boolean().optional().describe('Show what would happen without making changes'),
+    }),
+    handler: (args: Record<string, unknown>, context: HandlerContext): Promise<ToolResponse> => {
+      const syncArgs: SyncStoresArgs = {};
+      if (typeof args['reindex'] === 'boolean') {
+        syncArgs.reindex = args['reindex'];
+      }
+      if (typeof args['prune'] === 'boolean') {
+        syncArgs.prune = args['prune'];
+      }
+      if (typeof args['dryRun'] === 'boolean') {
+        syncArgs.dryRun = args['dryRun'];
+      }
+      return handleStoresSync(syncArgs, context);
+    },
+  },
+];

package/src/services/gitignore.service.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { GitignoreService } from './gitignore.service.js';
+import { rm, mkdtemp, writeFile, readFile, access } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('GitignoreService', () => {
+  let projectRoot: string;
+  let service: GitignoreService;
+
+  beforeEach(async () => {
+    projectRoot = await mkdtemp(join(tmpdir(), 'gitignore-test-'));
+    service = new GitignoreService(projectRoot);
+  });
+
+  afterEach(async () => {
+    await rm(projectRoot, { recursive: true, force: true });
+  });
+
+  describe('hasRequiredPatterns', () => {
+    it('returns false when .gitignore does not exist', async () => {
+      const has = await service.hasRequiredPatterns();
+      expect(has).toBe(false);
+    });
+
+    it('returns false when .gitignore exists but is empty', async () => {
+      await writeFile(join(projectRoot, '.gitignore'), '');
+      const has = await service.hasRequiredPatterns();
+      expect(has).toBe(false);
+    });
+
+    it('returns false when .gitignore is missing bluera patterns', async () => {
+      await writeFile(join(projectRoot, '.gitignore'), 'node_modules/\n*.log\n');
+      const has = await service.hasRequiredPatterns();
+      expect(has).toBe(false);
+    });
+
+    it('returns true when all required patterns are present', async () => {
+      const content = `
+node_modules/
+.bluera/
+!.bluera/bluera-knowledge/
+!.bluera/bluera-knowledge/stores.config.json
+`;
+      await writeFile(join(projectRoot, '.gitignore'), content);
+      const has = await service.hasRequiredPatterns();
+      expect(has).toBe(true);
+    });
+
+    it('returns false when only some patterns are present', async () => {
+      const content = `
+.bluera/
+`;
+      await writeFile(join(projectRoot, '.gitignore'), content);
+      const has = await service.hasRequiredPatterns();
+      expect(has).toBe(false);
+    });
+  });
+
+  describe('ensureGitignorePatterns', () => {
+    it('creates .gitignore if it does not exist', async () => {
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(true);
+      expect(result.message).toContain('Created');
+
+      // Verify file exists
+      const gitignorePath = join(projectRoot, '.gitignore');
+      await expect(access(gitignorePath)).resolves.toBeUndefined();
+    });
+
+    it('adds patterns to empty .gitignore', async () => {
+      await writeFile(join(projectRoot, '.gitignore'), '');
+
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(true);
+      expect(result.message).toContain('Updated');
+
+      const content = await readFile(join(projectRoot, '.gitignore'), 'utf-8');
+      expect(content).toContain('.bluera/');
+      expect(content).toContain('!.bluera/bluera-knowledge/');
+      expect(content).toContain('!.bluera/bluera-knowledge/stores.config.json');
+    });
+
+    it('appends patterns to existing .gitignore', async () => {
+      const existingContent = 'node_modules/\n*.log\n';
+      await writeFile(join(projectRoot, '.gitignore'), existingContent);
+
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(true);
+
+      const content = await readFile(join(projectRoot, '.gitignore'), 'utf-8');
+      // Should preserve existing content
+      expect(content).toContain('node_modules/');
+      expect(content).toContain('*.log');
+      // Should add new patterns
+      expect(content).toContain('.bluera/');
+      expect(content).toContain('!.bluera/bluera-knowledge/');
+    });
+
+    it('skips if all patterns already present', async () => {
+      const existingContent = `
+node_modules/
+.bluera/
+!.bluera/bluera-knowledge/
+!.bluera/bluera-knowledge/stores.config.json
+`;
+      await writeFile(join(projectRoot, '.gitignore'), existingContent);
+
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(false);
+      expect(result.message).toContain('already');
+    });
+
+    it('adds missing patterns when some are present', async () => {
+      const existingContent = '.bluera/\n';
+      await writeFile(join(projectRoot, '.gitignore'), existingContent);
+
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(true);
+
+      const content = await readFile(join(projectRoot, '.gitignore'), 'utf-8');
+      expect(content).toContain('!.bluera/bluera-knowledge/');
+      expect(content).toContain('!.bluera/bluera-knowledge/stores.config.json');
+    });
+
+    it('includes header comment in new additions', async () => {
+      const result = await service.ensureGitignorePatterns();
+
+      expect(result.updated).toBe(true);
+
+      const content = await readFile(join(projectRoot, '.gitignore'), 'utf-8');
+      expect(content).toContain('# Bluera Knowledge');
+    });
+
+    it('preserves trailing newline', async () => {
+      const existingContent = 'node_modules/\n';
+      await writeFile(join(projectRoot, '.gitignore'), existingContent);
+
+      await service.ensureGitignorePatterns();
+
+      const content = await readFile(join(projectRoot, '.gitignore'), 'utf-8');
+      expect(content.endsWith('\n')).toBe(true);
+    });
+  });
+
+  describe('getGitignorePath', () => {
+    it('returns correct path', () => {
+      const path = service.getGitignorePath();
+      expect(path).toBe(join(projectRoot, '.gitignore'));
+    });
+  });
+});