bluera-knowledge 0.14.0 → 0.14.2

package/src/services/store.service.ts

@@ -1,363 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, writeFile, mkdir, stat, access } from 'node:fs/promises';
-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';
-
-/**
- * Check if a file exists
- */
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface CreateStoreInput {
-  name: string;
-  type: StoreType;
-  path?: string | undefined;
-  url?: string | undefined;
-  description?: string | undefined;
-  tags?: string[] | undefined;
-  branch?: string | undefined;
-  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, options?: StoreServiceOptions) {
-    this.dataDir = dataDir;
-    this.definitionService = options?.definitionService ?? undefined;
-  }
-
-  async initialize(): Promise<void> {
-    await mkdir(this.dataDir, { recursive: true });
-    await this.loadRegistry();
-  }
-
-  /**
-   * 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'));
-    }
-
-    const existing = await this.getByName(input.name);
-    if (existing !== undefined) {
-      return err(new Error(`Store with name "${input.name}" already exists`));
-    }
-
-    const id = createStoreId(randomUUID());
-    const now = new Date();
-
-    let store: Store;
-
-    switch (input.type) {
-      case 'file': {
-        if (input.path === undefined) {
-          return err(new Error('Path is required for file stores'));
-        }
-        // Normalize path to absolute path (security: prevents path confusion)
-        const normalizedPath = resolve(input.path);
-        // Validate directory exists
-        try {
-          const stats = await stat(normalizedPath);
-          if (!stats.isDirectory()) {
-            return err(new Error(`Path is not a directory: ${normalizedPath}`));
-          }
-        } catch {
-          return err(new Error(`Directory does not exist: ${normalizedPath}`));
-        }
-        store = {
-          type: 'file',
-          id,
-          name: input.name,
-          path: normalizedPath,
-          description: input.description,
-          tags: input.tags,
-          status: 'ready',
-          createdAt: now,
-          updatedAt: now,
-        } satisfies FileStore;
-        break;
-      }
-
-      case 'repo': {
-        let repoPath = input.path;
-
-        // If URL provided, clone it
-        if (input.url !== undefined) {
-          const cloneDir = join(this.dataDir, 'repos', id);
-          const result = await cloneRepository({
-            url: input.url,
-            targetDir: cloneDir,
-            ...(input.branch !== undefined ? { branch: input.branch } : {}),
-            depth: input.depth ?? 1,
-          });
-
-          if (!result.success) {
-            return err(result.error);
-          }
-          repoPath = result.data;
-        }
-
-        if (repoPath === undefined) {
-          return err(new Error('Path or URL required for repo stores'));
-        }
-
-        // Normalize path to absolute path (security: prevents path confusion)
-        const normalizedRepoPath = resolve(repoPath);
-
-        store = {
-          type: 'repo',
-          id,
-          name: input.name,
-          path: normalizedRepoPath,
-          url: input.url,
-          branch: input.branch,
-          description: input.description,
-          tags: input.tags,
-          status: 'ready',
-          createdAt: now,
-          updatedAt: now,
-        } satisfies RepoStore;
-        break;
-      }
-
-      case 'web':
-        if (input.url === undefined) {
-          return err(new Error('URL is required for web stores'));
-        }
-        store = {
-          type: 'web',
-          id,
-          name: input.name,
-          url: input.url,
-          depth: input.depth ?? 1,
-          description: input.description,
-          tags: input.tags,
-          status: 'ready',
-          createdAt: now,
-          updatedAt: now,
-        } satisfies WebStore;
-        break;
-
-      default: {
-        // Exhaustive check - if this is reached, input.type is invalid
-        const invalidType: never = input.type;
-        return err(new Error(`Invalid store type: ${String(invalidType)}`));
-      }
-    }
-
-    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);
-  }
-
-  async list(type?: StoreType): Promise<Store[]> {
-    if (type !== undefined) {
-      return Promise.resolve(this.registry.stores.filter((s) => s.type === type));
-    }
-    return Promise.resolve([...this.registry.stores]);
-  }
-
-  async get(id: StoreId): Promise<Store | undefined> {
-    return Promise.resolve(this.registry.stores.find((s) => s.id === id));
-  }
-
-  async getByName(name: string): Promise<Store | undefined> {
-    return Promise.resolve(this.registry.stores.find((s) => s.name === name));
-  }
-
-  async getByIdOrName(idOrName: string): Promise<Store | undefined> {
-    return Promise.resolve(
-      this.registry.stores.find((s) => s.id === idOrName || s.name === idOrName)
-    );
-  }
-
-  async update(
-    id: StoreId,
-    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) {
-      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}`));
-    }
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const updated = {
-      ...store,
-      ...updates,
-      updatedAt: new Date(),
-    } as Store;
-
-    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, 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);
-  }
-
-  private async loadRegistry(): Promise<void> {
-    const registryPath = join(this.dataDir, 'stores.json');
-    const exists = await fileExists(registryPath);
-
-    if (!exists) {
-      // First run - create empty registry
-      this.registry = { stores: [] };
-      await this.saveRegistry();
-      return;
-    }
-
-    // File exists - load it (throws on corruption per CLAUDE.md "fail early")
-    const content = await readFile(registryPath, 'utf-8');
-    try {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const data = JSON.parse(content) as { stores: (Store | null)[] };
-      this.registry = {
-        stores: data.stores
-          .filter((s): s is Store => s !== null)
-          .map((s) => ({
-            ...s,
-            id: createStoreId(s.id),
-            createdAt: new Date(s.createdAt),
-            updatedAt: new Date(s.updatedAt),
-          })),
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to parse store registry at ${registryPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  private async saveRegistry(): Promise<void> {
-    const registryPath = join(this.dataDir, 'stores.json');
-    await writeFile(registryPath, JSON.stringify(this.registry, null, 2));
-  }
-}

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

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { estimateTokens, formatTokenCount } from './token.service.js';
-
-describe('token.service', () => {
-  describe('estimateTokens', () => {
-    it('returns 0 for empty string', () => {
-      expect(estimateTokens('')).toBe(0);
-    });
-
-    it('estimates tokens for short text', () => {
-      // "hello" = 5 chars, 5/3.5 = 1.43, ceil = 2
-      expect(estimateTokens('hello')).toBe(2);
-    });
-
-    it('estimates tokens for longer text', () => {
-      // 35 chars / 3.5 = 10 tokens
-      const text = 'a'.repeat(35);
-      expect(estimateTokens(text)).toBe(10);
-    });
-
-    it('rounds up token count', () => {
-      // 7 chars / 3.5 = 2 tokens exactly
-      expect(estimateTokens('abcdefg')).toBe(2);
-      // 8 chars / 3.5 = 2.29, ceil = 3
-      expect(estimateTokens('abcdefgh')).toBe(3);
-    });
-  });
-
-  describe('formatTokenCount', () => {
-    it('formats small counts without suffix', () => {
-      expect(formatTokenCount(100)).toBe('~100');
-      expect(formatTokenCount(999)).toBe('~999');
-    });
-
-    it('formats counts >= 1000 with k suffix', () => {
-      expect(formatTokenCount(1000)).toBe('~1.0k');
-      expect(formatTokenCount(1500)).toBe('~1.5k');
-      expect(formatTokenCount(10000)).toBe('~10.0k');
-    });
-
-    it('formats zero', () => {
-      expect(formatTokenCount(0)).toBe('~0');
-    });
-  });
-});

package/src/services/token.service.ts

@@ -1,33 +0,0 @@
-/**
- * Token estimation service using Anthropic's recommended heuristic.
- * For Claude 3+ models, Anthropic recommends ~3.5 characters per token
- * for English text. This varies by language.
- *
- * Note: The official @anthropic-ai/tokenizer package only works for
- * pre-Claude 3 models. For accurate counts on Claude 3+, use the
- * Token Count API. This heuristic is suitable for display purposes.
- */
-
-const CHARS_PER_TOKEN = 3.5;
-
-/**
- * Estimate token count for a string using character-based heuristic.
- * @param text - The text to estimate tokens for
- * @returns Estimated token count (rounded up)
- */
-export function estimateTokens(text: string): number {
-  if (!text) return 0;
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-
-/**
- * Format token count for display with appropriate suffix.
- * @param tokens - Token count
- * @returns Formatted string like "~1.2k" or "~847"
- */
-export function formatTokenCount(tokens: number): string {
-  if (tokens >= 1000) {
-    return `~${(tokens / 1000).toFixed(1)}k`;
-  }
-  return `~${String(tokens)}`;
-}