bluera-knowledge 0.14.0 → 0.14.2

package/src/services/code-unit.service.ts

@@ -1,234 +0,0 @@
-export interface CodeUnit {
-  type: 'function' | 'class' | 'interface' | 'type' | 'const' | 'documentation' | 'example';
-  name: string;
-  signature: string;
-  fullContent: string;
-  startLine: number;
-  endLine: number;
-  language: string;
-}
-
-export class CodeUnitService {
-  extractCodeUnit(code: string, symbolName: string, language: string): CodeUnit | undefined {
-    const lines = code.split('\n');
-
-    // Find the line containing the symbol
-    let startLine = -1;
-    let type: CodeUnit['type'] = 'function';
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i] ?? '';
-
-      if (line.includes(`function ${symbolName}`)) {
-        startLine = i + 1; // 1-indexed
-        type = 'function';
-        break;
-      }
-
-      if (line.includes(`class ${symbolName}`)) {
-        startLine = i + 1;
-        type = 'class';
-        break;
-      }
-
-      // Check for interface declarations
-      if (line.match(new RegExp(`interface\\s+${symbolName}(?:\\s|{|<)`))) {
-        startLine = i + 1;
-        type = 'interface';
-        break;
-      }
-
-      // Check for type declarations
-      if (line.match(new RegExp(`type\\s+${symbolName}(?:\\s|=|<)`))) {
-        startLine = i + 1;
-        type = 'type';
-        break;
-      }
-
-      // Check for arrow functions: const/let/var name = ...
-      if (line.match(new RegExp(`(?:const|let|var)\\s+${symbolName}\\s*=`))) {
-        startLine = i + 1;
-        type = 'const';
-        break;
-      }
-    }
-
-    if (startLine === -1) return undefined;
-
-    // Find end line using state machine that tracks strings and comments
-    let endLine = startLine;
-    let braceCount = 0;
-    let foundFirstBrace = false;
-
-    // For type aliases without braces (e.g., "type UserId = string;"), find semicolon
-    if (type === 'type') {
-      const firstLine = lines[startLine - 1] ?? '';
-      if (!firstLine.includes('{') && firstLine.includes(';')) {
-        // Single-line type alias
-        endLine = startLine;
-        const fullContent = firstLine;
-        const signature = this.extractSignature(firstLine, symbolName, type);
-        return {
-          type,
-          name: symbolName,
-          signature,
-          fullContent,
-          startLine,
-          endLine,
-          language,
-        };
-      }
-    }
-
-    // State machine for tracking context
-    let inSingleQuote = false;
-    let inDoubleQuote = false;
-    let inTemplateLiteral = false;
-    let inMultiLineComment = false;
-
-    for (let i = startLine - 1; i < lines.length; i++) {
-      const line = lines[i] ?? '';
-      let inSingleLineComment = false;
-
-      for (let j = 0; j < line.length; j++) {
-        const char = line[j];
-        const prevChar = j > 0 ? line[j - 1] : '';
-        const nextChar = j < line.length - 1 ? line[j + 1] : '';
-
-        // Skip escaped characters within strings
-        if (prevChar === '\\' && (inSingleQuote || inDoubleQuote || inTemplateLiteral)) {
-          continue;
-        }
-
-        // Inside multi-line comment - only look for end marker
-        if (inMultiLineComment) {
-          if (char === '*' && nextChar === '/') {
-            inMultiLineComment = false;
-            j++; // Skip the /
-          }
-          continue;
-        }
-
-        // Inside single-line comment - skip rest of line
-        if (inSingleLineComment) {
-          continue;
-        }
-
-        // Inside a string - only look for closing delimiter
-        if (inSingleQuote) {
-          if (char === "'") inSingleQuote = false;
-          continue;
-        }
-        if (inDoubleQuote) {
-          if (char === '"') inDoubleQuote = false;
-          continue;
-        }
-        if (inTemplateLiteral) {
-          if (char === '`') inTemplateLiteral = false;
-          continue;
-        }
-
-        // Not inside any special context - check for context starters
-        if (char === '/' && nextChar === '*') {
-          inMultiLineComment = true;
-          j++; // Skip the *
-          continue;
-        }
-        if (char === '/' && nextChar === '/') {
-          inSingleLineComment = true;
-          continue;
-        }
-        if (char === "'") {
-          inSingleQuote = true;
-          continue;
-        }
-        if (char === '"') {
-          inDoubleQuote = true;
-          continue;
-        }
-        if (char === '`') {
-          inTemplateLiteral = true;
-          continue;
-        }
-
-        // Count braces (we're not inside any string or comment)
-        if (char === '{') {
-          braceCount++;
-          foundFirstBrace = true;
-        }
-        if (char === '}') braceCount--;
-      }
-
-      if (foundFirstBrace && braceCount === 0) {
-        endLine = i + 1;
-        break;
-      }
-    }
-
-    const fullContent = lines.slice(startLine - 1, endLine).join('\n');
-
-    // Extract signature (first line, cleaned)
-    const firstLine = lines[startLine - 1] ?? '';
-    const signature = this.extractSignature(firstLine, symbolName, type);
-
-    return {
-      type,
-      name: symbolName,
-      signature,
-      fullContent,
-      startLine,
-      endLine,
-      language,
-    };
-  }
-
-  private extractSignature(line: string, name: string, type: string): string {
-    // Remove 'export', 'async', trim whitespace
-    const sig = line
-      .replace(/^\s*export\s+/, '')
-      .replace(/^\s*async\s+/, '')
-      .trim();
-
-    if (type === 'function') {
-      // Extract just "functionName(params): returnType"
-      // Supports: simple types, generics (Promise<T>), arrays (T[]), unions (T | null)
-      const match = sig.match(/function\s+(\w+\([^)]*\):\s*[\w<>[\],\s|]+)/);
-      if (match?.[1] !== undefined && match[1].length > 0) return match[1].trim();
-    }
-
-    if (type === 'class') {
-      return `class ${name}`;
-    }
-
-    if (type === 'interface') {
-      return `interface ${name}`;
-    }
-
-    if (type === 'type') {
-      // For type aliases, include generics if present
-      const typeMatch = sig.match(new RegExp(`type\\s+(${name}(?:<[^>]+>)?)\\s*=`));
-      if (typeMatch?.[1] !== undefined && typeMatch[1].length > 0) {
-        return `type ${typeMatch[1]}`;
-      }
-      return `type ${name}`;
-    }
-
-    if (type === 'const') {
-      // For arrow functions, extract the variable declaration part
-      // Example: const myFunc = (param: string): void => ...
-      // Returns: const myFunc = (param: string): void
-      const arrowMatch = sig.match(
-        new RegExp(
-          `((?:const|let|var)\\s+${name}\\s*=\\s*(?:async\\s+)?\\([^)]*\\)(?::\\s*[^=]+)?)`
-        )
-      );
-      const matchedSig = arrowMatch?.[1];
-      if (matchedSig !== undefined && matchedSig !== '') return matchedSig.trim();
-
-      // Fallback for simple arrow functions without params
-      return `const ${name}`;
-    }
-
-    return sig;
-  }
-}

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

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ConfigService } from './config.service.js';
-import { rm, mkdtemp, writeFile, access } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-describe('ConfigService', () => {
-  let configService: ConfigService;
-  let tempDir: string;
-  let configPath: string;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'config-test-'));
-    configPath = join(tempDir, 'config.json');
-    configService = new ConfigService(configPath, tempDir);
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  it('loads default config when no file exists', async () => {
-    const config = await configService.load();
-    expect(config.version).toBe(1);
-    expect(config.embedding.model).toBe('Xenova/all-MiniLM-L6-v2');
-  });
-
-  it('saves and loads config', async () => {
-    const config = await configService.load();
-    config.search.defaultLimit = 20;
-    await configService.save(config);
-
-    const loaded = await configService.load();
-    expect(loaded.search.defaultLimit).toBe(20);
-  });
-
-  it('resolves data directory path', async () => {
-    const config = await configService.load();
-    const dataDir = configService.resolveDataDir();
-    expect(dataDir).toBe(tempDir);
-  });
-
-  describe('path expansion', () => {
-    it('expands tilde to home directory', () => {
-      const service = new ConfigService(configPath, '~/.bluera/data');
-      const dataDir = service.resolveDataDir();
-      // Note: expandPath is called in constructor, so ~ will be kept
-      // since dataDir parameter is explicitly provided
-      expect(dataDir).toBe('~/.bluera/data');
-    });
-
-    it('resolves relative paths against project root', () => {
-      const service = new ConfigService(configPath, undefined, tempDir);
-      const dataDir = service.resolveDataDir();
-      // When dataDir is undefined, it uses DEFAULT_CONFIG.dataDir which is relative
-      expect(dataDir).toContain(tempDir);
-    });
-
-    it('keeps absolute paths as-is', () => {
-      const absolutePath = '/absolute/path/to/data';
-      const service = new ConfigService(configPath, absolutePath);
-      const dataDir = service.resolveDataDir();
-      expect(dataDir).toBe(absolutePath);
-    });
-
-    it('uses explicit dataDir when provided', () => {
-      const explicitDir = '/explicit/data/dir';
-      const service = new ConfigService(configPath, explicitDir);
-      const dataDir = service.resolveDataDir();
-      expect(dataDir).toBe(explicitDir);
-    });
-
-    it('uses default path resolution when dataDir is empty string', () => {
-      const service = new ConfigService(
-        configPath,
-        '' // Empty string triggers default path logic
-      );
-      const dataDir = service.resolveDataDir();
-      // Empty string is not undefined, so it should resolve relative default
-      expect(dataDir).toContain('.bluera/bluera-knowledge/data');
-    });
-  });
-
-  describe('config caching', () => {
-    it('caches loaded config', async () => {
-      const config1 = await configService.load();
-      const config2 = await configService.load();
-      expect(config1).toBe(config2); // Same reference
-    });
-
-    it('updates cache when saving', async () => {
-      const config = await configService.load();
-      config.search.defaultLimit = 25;
-      await configService.save(config);
-
-      const loaded = await configService.load();
-      expect(loaded.search.defaultLimit).toBe(25);
-    });
-  });
-
-  describe('config persistence', () => {
-    it('creates config directory if it does not exist', async () => {
-      const deepPath = join(tempDir, 'deep', 'nested', 'path', 'config.json');
-      const service = new ConfigService(deepPath, tempDir);
-
-      const config = await service.load();
-      await service.save(config);
-
-      // Should successfully save to deep path
-      const loaded = await service.load();
-      expect(loaded).toBeDefined();
-    });
-  });
-
-  describe('first-run vs corruption handling (CLAUDE.md compliance)', () => {
-    it('creates config file on first run when missing', async () => {
-      // Config file does not exist
-      const config = await configService.load();
-
-      // Should return default config
-      expect(config.version).toBe(1);
-
-      // File should now exist (created automatically)
-      await expect(access(configPath)).resolves.toBeUndefined();
-    });
-
-    it('throws on corrupted config file', async () => {
-      // Create corrupted config file
-      await writeFile(configPath, '{invalid json syntax');
-
-      // Create fresh service (no cache)
-      const freshService = new ConfigService(configPath, tempDir);
-
-      // Should throw per CLAUDE.md "fail early and fast"
-      await expect(freshService.load()).rejects.toThrow();
-    });
-
-    it('throws with descriptive message on JSON parse error', async () => {
-      await writeFile(configPath, '{"incomplete":');
-
-      const freshService = new ConfigService(configPath, tempDir);
-
-      await expect(freshService.load()).rejects.toThrow(/JSON|parse|config/i);
-    });
-  });
-});

package/src/services/config.service.ts

@@ -1,92 +0,0 @@
-import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, resolve } from 'node:path';
-import { ProjectRootService } from './project-root.service.js';
-import { DEFAULT_CONFIG } from '../types/config.js';
-import type { AppConfig } from '../types/config.js';
-
-/**
- * Check if a file exists
- */
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export class ConfigService {
-  private readonly configPath: string;
-  private readonly dataDir: string;
-  private config: AppConfig | null = null;
-
-  constructor(
-    configPath = `${homedir()}/.bluera/bluera-knowledge/config.json`,
-    dataDir?: string,
-    projectRoot?: string
-  ) {
-    this.configPath = configPath;
-
-    if (dataDir !== undefined && dataDir !== '') {
-      // Explicit dataDir provided, use it as-is
-      this.dataDir = dataDir;
-    } else {
-      // Resolve project root using hierarchical detection
-      const root = projectRoot ?? ProjectRootService.resolve();
-      // Expand relative default path against project root
-      this.dataDir = this.expandPath(DEFAULT_CONFIG.dataDir, root);
-    }
-  }
-
-  async load(): Promise<AppConfig> {
-    if (this.config !== null) {
-      return this.config;
-    }
-
-    const exists = await fileExists(this.configPath);
-    if (!exists) {
-      // First run - create config file with defaults
-      this.config = { ...DEFAULT_CONFIG };
-      await this.save(this.config);
-      return this.config;
-    }
-
-    // File exists - load it (throws on corruption per CLAUDE.md "fail early")
-    const content = await readFile(this.configPath, 'utf-8');
-    try {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) } as AppConfig;
-    } catch (error) {
-      throw new Error(
-        `Failed to parse config file at ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-
-    return this.config;
-  }
-
-  async save(config: AppConfig): Promise<void> {
-    await mkdir(dirname(this.configPath), { recursive: true });
-    await writeFile(this.configPath, JSON.stringify(config, null, 2));
-    this.config = config;
-  }
-
-  resolveDataDir(): string {
-    return this.dataDir;
-  }
-
-  private expandPath(path: string, baseDir: string): string {
-    // Expand ~ to home directory
-    if (path.startsWith('~')) {
-      return path.replace('~', homedir());
-    }
-    // Resolve relative paths against base directory (not process.cwd())
-    if (!path.startsWith('/')) {
-      return resolve(baseDir, path);
-    }
-    // Return absolute paths as-is
-    return path;
-  }
-}

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

@@ -1,157 +0,0 @@
-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'));
-    });
-  });
-});