bluera-knowledge 0.10.0 → 0.11.0

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

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { StoreService } from './store.service.js';
-import { rm, mkdtemp, writeFile, access } from 'node:fs/promises';
+import { StoreDefinitionService } from './store-definition.service.js';
+import { rm, mkdtemp, writeFile, readFile, access } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -538,4 +539,281 @@ describe('StoreService', () => {
       await rm(corruptDir, { recursive: true, force: true });
     });
   });
+
+  describe('store definition auto-update', () => {
+    let projectRoot: string;
+    let dataDir: string;
+    let serviceWithDefs: StoreService;
+    let defService: StoreDefinitionService;
+
+    beforeEach(async () => {
+      projectRoot = await mkdtemp(join(tmpdir(), 'store-def-auto-'));
+      dataDir = join(projectRoot, '.bluera/bluera-knowledge/data');
+      defService = new StoreDefinitionService(projectRoot);
+      serviceWithDefs = new StoreService(dataDir, { definitionService: defService });
+      await serviceWithDefs.initialize();
+    });
+
+    afterEach(async () => {
+      await rm(projectRoot, { recursive: true, force: true });
+    });
+
+    describe('create adds definition', () => {
+      it('adds file store definition when creating file store', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'file-store-'));
+        const result = await serviceWithDefs.create({
+          name: 'my-docs',
+          type: 'file',
+          path: storeDir,
+          description: 'My documentation',
+          tags: ['docs'],
+        });
+
+        expect(result.success).toBe(true);
+
+        const def = await defService.getByName('my-docs');
+        expect(def).toBeDefined();
+        expect(def?.type).toBe('file');
+        expect(def?.name).toBe('my-docs');
+        if (def?.type === 'file') {
+          expect(def.path).toBe(storeDir);
+        }
+        expect(def?.description).toBe('My documentation');
+        expect(def?.tags).toEqual(['docs']);
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+
+      it('adds repo store definition when creating repo store with path', async () => {
+        const repoDir = await mkdtemp(join(tmpdir(), 'repo-store-'));
+        const result = await serviceWithDefs.create({
+          name: 'my-repo',
+          type: 'repo',
+          path: repoDir,
+          branch: 'main',
+          description: 'Example repo',
+        });
+
+        expect(result.success).toBe(true);
+
+        const def = await defService.getByName('my-repo');
+        expect(def).toBeDefined();
+        expect(def?.type).toBe('repo');
+        if (def?.type === 'repo') {
+          expect(def.branch).toBe('main');
+        }
+
+        await rm(repoDir, { recursive: true, force: true });
+      });
+
+      it('adds web store definition when creating web store', async () => {
+        const result = await serviceWithDefs.create({
+          name: 'my-site',
+          type: 'web',
+          url: 'https://example.com/docs',
+          depth: 2,
+          description: 'Example site',
+        });
+
+        expect(result.success).toBe(true);
+
+        const def = await defService.getByName('my-site');
+        expect(def).toBeDefined();
+        expect(def?.type).toBe('web');
+        if (def?.type === 'web') {
+          expect(def.url).toBe('https://example.com/docs');
+          expect(def.depth).toBe(2);
+        }
+      });
+
+      it('does not add definition when store creation fails', async () => {
+        const result = await serviceWithDefs.create({
+          name: 'bad-store',
+          type: 'file',
+          path: '/nonexistent/path',
+        });
+
+        expect(result.success).toBe(false);
+
+        const def = await defService.getByName('bad-store');
+        expect(def).toBeUndefined();
+      });
+
+      it('does not add definition when skipDefinitionSync is true', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'skip-def-'));
+        const result = await serviceWithDefs.create(
+          {
+            name: 'skip-store',
+            type: 'file',
+            path: storeDir,
+          },
+          { skipDefinitionSync: true }
+        );
+
+        expect(result.success).toBe(true);
+
+        const def = await defService.getByName('skip-store');
+        expect(def).toBeUndefined();
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+    });
+
+    describe('delete removes definition', () => {
+      it('removes definition when store is deleted', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'del-store-'));
+        const createResult = await serviceWithDefs.create({
+          name: 'to-delete',
+          type: 'file',
+          path: storeDir,
+        });
+
+        if (!createResult.success) throw new Error('Create failed');
+
+        // Verify definition exists
+        let def = await defService.getByName('to-delete');
+        expect(def).toBeDefined();
+
+        // Delete the store
+        const deleteResult = await serviceWithDefs.delete(createResult.data.id);
+        expect(deleteResult.success).toBe(true);
+
+        // Definition should be removed
+        def = await defService.getByName('to-delete');
+        expect(def).toBeUndefined();
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+
+      it('does not remove definition when skipDefinitionSync is true', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'del-skip-'));
+        const createResult = await serviceWithDefs.create({
+          name: 'keep-def',
+          type: 'file',
+          path: storeDir,
+        });
+
+        if (!createResult.success) throw new Error('Create failed');
+
+        // Delete with skipDefinitionSync
+        const deleteResult = await serviceWithDefs.delete(createResult.data.id, {
+          skipDefinitionSync: true,
+        });
+        expect(deleteResult.success).toBe(true);
+
+        // Definition should still exist
+        const def = await defService.getByName('keep-def');
+        expect(def).toBeDefined();
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+    });
+
+    describe('update syncs definition', () => {
+      it('updates definition when store description is updated', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'upd-store-'));
+        const createResult = await serviceWithDefs.create({
+          name: 'to-update',
+          type: 'file',
+          path: storeDir,
+          description: 'Original description',
+        });
+
+        if (!createResult.success) throw new Error('Create failed');
+
+        const updateResult = await serviceWithDefs.update(createResult.data.id, {
+          description: 'Updated description',
+        });
+        expect(updateResult.success).toBe(true);
+
+        const def = await defService.getByName('to-update');
+        expect(def?.description).toBe('Updated description');
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+
+      it('updates definition when store tags are updated', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'upd-tags-'));
+        const createResult = await serviceWithDefs.create({
+          name: 'tag-store',
+          type: 'file',
+          path: storeDir,
+          tags: ['old'],
+        });
+
+        if (!createResult.success) throw new Error('Create failed');
+
+        const updateResult = await serviceWithDefs.update(createResult.data.id, {
+          tags: ['new', 'tags'],
+        });
+        expect(updateResult.success).toBe(true);
+
+        const def = await defService.getByName('tag-store');
+        expect(def?.tags).toEqual(['new', 'tags']);
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+
+      it('does not update definition when skipDefinitionSync is true', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'upd-skip-'));
+        const createResult = await serviceWithDefs.create({
+          name: 'skip-update',
+          type: 'file',
+          path: storeDir,
+          description: 'Original',
+        });
+
+        if (!createResult.success) throw new Error('Create failed');
+
+        const updateResult = await serviceWithDefs.update(
+          createResult.data.id,
+          { description: 'Updated' },
+          { skipDefinitionSync: true }
+        );
+        expect(updateResult.success).toBe(true);
+
+        const def = await defService.getByName('skip-update');
+        expect(def?.description).toBe('Original');
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+    });
+
+    describe('persistence', () => {
+      it('persists definition to config file', async () => {
+        const storeDir = await mkdtemp(join(tmpdir(), 'persist-def-'));
+        await serviceWithDefs.create({
+          name: 'persistent-store',
+          type: 'file',
+          path: storeDir,
+        });
+
+        // Read config file directly
+        const configPath = join(projectRoot, '.bluera/bluera-knowledge/stores.config.json');
+        const content = await readFile(configPath, 'utf-8');
+        const config = JSON.parse(content);
+
+        expect(config.stores).toHaveLength(1);
+        expect(config.stores[0].name).toBe('persistent-store');
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+    });
+
+    describe('without definition service', () => {
+      it('works normally without definition service injected', async () => {
+        // Use the storeService from outer scope (no definition service)
+        const storeDir = await mkdtemp(join(tmpdir(), 'no-def-'));
+        const result = await storeService.create({
+          name: 'no-def-store',
+          type: 'file',
+          path: storeDir,
+        });
+
+        expect(result.success).toBe(true);
+
+        await rm(storeDir, { recursive: true, force: true });
+      });
+    });
+  });
 });

package/src/services/store.service.ts

@@ -4,8 +4,15 @@ import { join, resolve } from 'node:path';
 import { cloneRepository } from '../plugin/git-clone.js';
 import { createStoreId } from '../types/brands.js';
 import { ok, err } from '../types/result.js';
+import type { StoreDefinitionService } from './store-definition.service.js';
 import type { StoreId } from '../types/brands.js';
 import type { Result } from '../types/result.js';
+import type {
+  StoreDefinition,
+  FileStoreDefinition,
+  RepoStoreDefinition,
+  WebStoreDefinition,
+} from '../types/store-definition.js';
 import type { Store, FileStore, RepoStore, WebStore, StoreType } from '../types/store.js';
 
 /**
@@ -31,16 +38,28 @@ export interface CreateStoreInput {
   depth?: number | undefined;
 }
 
+export interface StoreServiceOptions {
+  /** Optional definition service for auto-updating git-committable config */
+  definitionService?: StoreDefinitionService;
+}
+
+export interface OperationOptions {
+  /** Skip syncing to store definitions (used by stores:sync command) */
+  skipDefinitionSync?: boolean;
+}
+
 interface StoreRegistry {
   stores: Store[];
 }
 
 export class StoreService {
   private readonly dataDir: string;
+  private readonly definitionService: StoreDefinitionService | undefined;
   private registry: StoreRegistry = { stores: [] };
 
-  constructor(dataDir: string) {
+  constructor(dataDir: string, options?: StoreServiceOptions) {
     this.dataDir = dataDir;
+    this.definitionService = options?.definitionService ?? undefined;
   }
 
   async initialize(): Promise<void> {
@@ -48,7 +67,54 @@ export class StoreService {
     await this.loadRegistry();
   }
 
-  async create(input: CreateStoreInput): Promise<Result<Store>> {
+  /**
+   * Convert a Store and CreateStoreInput to a StoreDefinition for persistence.
+   */
+  private createDefinitionFromStore(store: Store, input: CreateStoreInput): StoreDefinition {
+    // Copy tags array to convert from readonly to mutable
+    const tags = store.tags !== undefined ? [...store.tags] : undefined;
+    const base = {
+      name: store.name,
+      description: store.description,
+      tags,
+    };
+
+    switch (store.type) {
+      case 'file': {
+        const fileStore = store;
+        const fileDef: FileStoreDefinition = {
+          ...base,
+          type: 'file',
+          // Use original input path if provided (may be relative), otherwise use normalized
+          path: input.path ?? fileStore.path,
+        };
+        return fileDef;
+      }
+      case 'repo': {
+        const repoStore = store;
+        const repoDef: RepoStoreDefinition = {
+          ...base,
+          type: 'repo',
+          url: repoStore.url ?? '',
+          branch: repoStore.branch,
+          depth: input.depth,
+        };
+        return repoDef;
+      }
+      case 'web': {
+        const webStore = store;
+        const webDef: WebStoreDefinition = {
+          ...base,
+          type: 'web',
+          url: webStore.url,
+          depth: webStore.depth,
+        };
+        return webDef;
+      }
+    }
+  }
+
+  async create(input: CreateStoreInput, options?: OperationOptions): Promise<Result<Store>> {
     if (!input.name || input.name.trim() === '') {
       return err(new Error('Store name cannot be empty'));
     }
@@ -157,6 +223,12 @@ export class StoreService {
     this.registry.stores.push(store);
     await this.saveRegistry();
 
+    // Sync to store definitions if service is available and not skipped
+    if (this.definitionService !== undefined && options?.skipDefinitionSync !== true) {
+      const definition = this.createDefinitionFromStore(store, input);
+      await this.definitionService.addDefinition(definition);
+    }
+
     return ok(store);
   }
 
@@ -183,7 +255,8 @@ export class StoreService {
 
   async update(
     id: StoreId,
-    updates: Partial<Pick<Store, 'name' | 'description' | 'tags'>>
+    updates: Partial<Pick<Store, 'name' | 'description' | 'tags'>>,
+    options?: OperationOptions
   ): Promise<Result<Store>> {
     const index = this.registry.stores.findIndex((s) => s.id === id);
     if (index === -1) {
@@ -205,18 +278,42 @@ export class StoreService {
     this.registry.stores[index] = updated;
     await this.saveRegistry();
 
+    // Sync to store definitions if service is available and not skipped
+    if (this.definitionService !== undefined && options?.skipDefinitionSync !== true) {
+      const defUpdates: { description?: string; tags?: string[] } = {};
+      if (updates.description !== undefined) {
+        defUpdates.description = updates.description;
+      }
+      if (updates.tags !== undefined) {
+        // Copy tags array to convert from readonly to mutable
+        defUpdates.tags = [...updates.tags];
+      }
+      await this.definitionService.updateDefinition(store.name, defUpdates);
+    }
+
     return ok(updated);
   }
 
-  async delete(id: StoreId): Promise<Result<void>> {
+  async delete(id: StoreId, options?: OperationOptions): Promise<Result<void>> {
     const index = this.registry.stores.findIndex((s) => s.id === id);
     if (index === -1) {
       return err(new Error(`Store not found: ${id}`));
     }
 
+    const store = this.registry.stores[index];
+    if (store === undefined) {
+      return err(new Error(`Store not found: ${id}`));
+    }
+
+    const storeName = store.name;
     this.registry.stores.splice(index, 1);
     await this.saveRegistry();
 
+    // Sync to store definitions if service is available and not skipped
+    if (this.definitionService !== undefined && options?.skipDefinitionSync !== true) {
+      await this.definitionService.removeDefinition(storeName);
+    }
+
     return ok(undefined);
   }
 

package/src/types/index.ts

@@ -53,3 +53,21 @@ export {
 
 // Progress types
 export { type ProgressEvent, type ProgressCallback } from './progress.js';
+
+// Store definition types (for git-committable config)
+export {
+  type StoreDefinition,
+  type FileStoreDefinition,
+  type RepoStoreDefinition,
+  type WebStoreDefinition,
+  type StoreDefinitionsConfig,
+  StoreDefinitionSchema,
+  FileStoreDefinitionSchema,
+  RepoStoreDefinitionSchema,
+  WebStoreDefinitionSchema,
+  StoreDefinitionsConfigSchema,
+  isFileStoreDefinition,
+  isRepoStoreDefinition,
+  isWebStoreDefinition,
+  DEFAULT_STORE_DEFINITIONS_CONFIG,
+} from './store-definition.js';