bluera-knowledge 0.14.0 → 0.14.2

package/src/services/chunking.service.ts

@@ -1,380 +0,0 @@
-export interface ChunkConfig {
-  chunkSize: number;
-  chunkOverlap: number;
-}
-
-export interface Chunk {
-  content: string;
-  chunkIndex: number;
-  totalChunks: number;
-  startOffset: number;
-  endOffset: number;
-  /** Section header if this chunk starts a markdown section */
-  sectionHeader?: string | undefined;
-  /** Function or class name if this chunk contains a code declaration */
-  functionName?: string | undefined;
-  /** JSDoc/comment summary extracted from this chunk */
-  docSummary?: string | undefined;
-}
-
-/**
- * Preset configurations for different content types.
- * Code uses smaller chunks for precise symbol matching.
- * Web/docs use larger chunks to preserve prose context.
- */
-const CHUNK_PRESETS = {
-  code: { chunkSize: 768, chunkOverlap: 100 },
-  web: { chunkSize: 1200, chunkOverlap: 200 },
-  docs: { chunkSize: 1200, chunkOverlap: 200 },
-} as const;
-
-export type ContentType = keyof typeof CHUNK_PRESETS;
-
-export class ChunkingService {
-  private readonly chunkSize: number;
-  private readonly chunkOverlap: number;
-
-  constructor(config: ChunkConfig) {
-    this.chunkSize = config.chunkSize;
-    this.chunkOverlap = config.chunkOverlap;
-  }
-
-  /**
-   * Create a ChunkingService with preset configuration for a content type.
-   * - 'code': Smaller chunks (768/100) for precise code symbol matching
-   * - 'web': Larger chunks (1200/200) for web prose content
-   * - 'docs': Larger chunks (1200/200) for documentation
-   */
-  static forContentType(type: ContentType): ChunkingService {
-    return new ChunkingService(CHUNK_PRESETS[type]);
-  }
-
-  /**
-   * Chunk text content. Uses semantic chunking for Markdown and code files,
-   * falling back to sliding window for other content.
-   */
-  chunk(text: string, filePath?: string): Chunk[] {
-    // Use semantic chunking for Markdown files
-    if (filePath !== undefined && filePath !== '' && /\.md$/i.test(filePath)) {
-      return this.chunkMarkdown(text);
-    }
-
-    // Use semantic chunking for TypeScript/JavaScript files
-    if (filePath !== undefined && filePath !== '' && /\.(ts|tsx|js|jsx)$/i.test(filePath)) {
-      return this.chunkCode(text);
-    }
-
-    return this.chunkSlidingWindow(text);
-  }
-
-  /**
-   * Semantic chunking for Markdown files.
-   * Splits on section headers to keep related content together.
-   */
-  private chunkMarkdown(text: string): Chunk[] {
-    // Match markdown headers (# through ####)
-    const headerRegex = /^(#{1,4})\s+(.+)$/gm;
-    const sections: Array<{ header: string; content: string; startOffset: number }> = [];
-
-    let lastIndex = 0;
-    let lastHeader = '';
-    let match: RegExpExecArray | null;
-
-    while ((match = headerRegex.exec(text)) !== null) {
-      // Save previous section
-      if (match.index > lastIndex) {
-        const content = text.slice(lastIndex, match.index).trim();
-        if (content) {
-          sections.push({
-            header: lastHeader,
-            content: content,
-            startOffset: lastIndex,
-          });
-        }
-      }
-      lastHeader = match[2] ?? '';
-      lastIndex = match.index;
-    }
-
-    // Add final section
-    const finalContent = text.slice(lastIndex).trim();
-    if (finalContent) {
-      sections.push({
-        header: lastHeader,
-        content: finalContent,
-        startOffset: lastIndex,
-      });
-    }
-
-    // If no sections found, fall back to sliding window
-    if (sections.length === 0) {
-      return this.chunkSlidingWindow(text);
-    }
-
-    // Convert sections to chunks, splitting large sections if needed
-    const chunks: Chunk[] = [];
-
-    for (const section of sections) {
-      if (section.content.length <= this.chunkSize) {
-        // Section fits in one chunk
-        chunks.push({
-          content: section.content,
-          chunkIndex: chunks.length,
-          totalChunks: 0,
-          startOffset: section.startOffset,
-          endOffset: section.startOffset + section.content.length,
-          sectionHeader: section.header || undefined,
-        });
-      } else {
-        // Split large section using sliding window
-        const sectionChunks = this.chunkSlidingWindow(section.content);
-        for (const subChunk of sectionChunks) {
-          chunks.push({
-            ...subChunk,
-            chunkIndex: chunks.length,
-            startOffset: section.startOffset + subChunk.startOffset,
-            endOffset: section.startOffset + subChunk.endOffset,
-            sectionHeader: section.header || undefined,
-          });
-        }
-      }
-    }
-
-    // Set totalChunks
-    for (const chunk of chunks) {
-      chunk.totalChunks = chunks.length;
-    }
-
-    return chunks;
-  }
-
-  /**
-   * Semantic chunking for TypeScript/JavaScript code files.
-   * Splits on top-level declarations to keep functions/classes together.
-   */
-  private chunkCode(text: string): Chunk[] {
-    // Match top-level declarations with optional JSDoc/comments before them
-    const declarationRegex =
-      /^(?:\/\*\*[\s\S]*?\*\/\s*)?(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|const|let|var|enum)\s+(\w+)/gm;
-    const declarations: Array<{ startOffset: number; endOffset: number; name?: string }> = [];
-
-    let match: RegExpExecArray | null;
-    while ((match = declarationRegex.exec(text)) !== null) {
-      const name = match[1];
-      const decl: { startOffset: number; endOffset: number; name?: string } = {
-        startOffset: match.index,
-        endOffset: match.index,
-      };
-      if (name !== undefined) {
-        decl.name = name;
-      }
-      declarations.push(decl);
-    }
-
-    // If no declarations found, use sliding window
-    if (declarations.length === 0) {
-      return this.chunkSlidingWindow(text);
-    }
-
-    // Find end of each declaration using brace-aware boundary detection
-    for (let i = 0; i < declarations.length; i++) {
-      const currentDecl = declarations[i];
-      const nextDecl = declarations[i + 1];
-      if (currentDecl === undefined) continue;
-
-      // For declarations that likely have braces (functions, classes, enums)
-      // use smart boundary detection
-      const declText = text.slice(currentDecl.startOffset);
-      if (
-        /^(?:\/\*\*[\s\S]*?\*\/\s*)?(?:export\s+)?(?:async\s+)?(?:function|class|enum)\s+/m.test(
-          declText
-        )
-      ) {
-        const boundary = this.findDeclarationEnd(declText);
-        if (boundary > 0) {
-          currentDecl.endOffset = currentDecl.startOffset + boundary;
-        } else {
-          // Fall back to next declaration or EOF
-          currentDecl.endOffset = nextDecl !== undefined ? nextDecl.startOffset : text.length;
-        }
-      } else {
-        // For other declarations (interface, type, const, let, var), use next declaration or EOF
-        currentDecl.endOffset = nextDecl !== undefined ? nextDecl.startOffset : text.length;
-      }
-    }
-
-    const chunks: Chunk[] = [];
-
-    for (const decl of declarations) {
-      const content = text.slice(decl.startOffset, decl.endOffset).trim();
-
-      if (content.length <= this.chunkSize) {
-        // Declaration fits in one chunk
-        chunks.push({
-          content,
-          chunkIndex: chunks.length,
-          totalChunks: 0,
-          startOffset: decl.startOffset,
-          endOffset: decl.endOffset,
-          functionName: decl.name,
-        });
-      } else {
-        // Split large declaration with sliding window
-        const declChunks = this.chunkSlidingWindow(content);
-        for (const subChunk of declChunks) {
-          chunks.push({
-            ...subChunk,
-            chunkIndex: chunks.length,
-            startOffset: decl.startOffset + subChunk.startOffset,
-            endOffset: decl.startOffset + subChunk.endOffset,
-            functionName: decl.name,
-          });
-        }
-      }
-    }
-
-    // Set totalChunks
-    for (const chunk of chunks) {
-      chunk.totalChunks = chunks.length;
-    }
-
-    return chunks.length > 0 ? chunks : this.chunkSlidingWindow(text);
-  }
-
-  /**
-   * Find the end of a code declaration by counting braces while ignoring
-   * braces inside strings and comments.
-   * Returns the offset where the declaration ends, or -1 if not found.
-   */
-  private findDeclarationEnd(text: string): number {
-    let braceCount = 0;
-    let inString = false;
-    let inSingleLineComment = false;
-    let inMultiLineComment = false;
-    let stringChar = '';
-    let i = 0;
-    let foundFirstBrace = false;
-
-    // Find the first opening brace
-    while (i < text.length) {
-      const char = text[i];
-      const nextChar = i + 1 < text.length ? text[i + 1] : '';
-
-      // Handle comments
-      if (!inString && !inMultiLineComment && char === '/' && nextChar === '/') {
-        inSingleLineComment = true;
-        i += 2;
-        continue;
-      }
-
-      if (!inString && !inSingleLineComment && char === '/' && nextChar === '*') {
-        inMultiLineComment = true;
-        i += 2;
-        continue;
-      }
-
-      if (inMultiLineComment && char === '*' && nextChar === '/') {
-        inMultiLineComment = false;
-        i += 2;
-        continue;
-      }
-
-      if (inSingleLineComment && char === '\n') {
-        inSingleLineComment = false;
-        i++;
-        continue;
-      }
-
-      // Skip if in comment
-      if (inSingleLineComment || inMultiLineComment) {
-        i++;
-        continue;
-      }
-
-      // Handle strings
-      if (!inString && (char === '"' || char === "'" || char === '`')) {
-        inString = true;
-        stringChar = char;
-        i++;
-        continue;
-      }
-
-      if (inString && char === '\\') {
-        // Skip escaped character
-        i += 2;
-        continue;
-      }
-
-      if (inString && char === stringChar) {
-        inString = false;
-        stringChar = '';
-        i++;
-        continue;
-      }
-
-      // Skip if in string
-      if (inString) {
-        i++;
-        continue;
-      }
-
-      // Count braces
-      if (char === '{') {
-        braceCount++;
-        foundFirstBrace = true;
-      } else if (char === '}') {
-        braceCount--;
-        if (foundFirstBrace && braceCount === 0) {
-          // Found the closing brace
-          return i + 1;
-        }
-      }
-
-      i++;
-    }
-
-    // If we didn't find a complete declaration, return -1
-    return -1;
-  }
-
-  /**
-   * Traditional sliding window chunking for non-Markdown content.
-   */
-  private chunkSlidingWindow(text: string): Chunk[] {
-    if (text.length <= this.chunkSize) {
-      return [
-        {
-          content: text,
-          chunkIndex: 0,
-          totalChunks: 1,
-          startOffset: 0,
-          endOffset: text.length,
-        },
-      ];
-    }
-
-    const chunks: Chunk[] = [];
-    const step = this.chunkSize - this.chunkOverlap;
-    let start = 0;
-
-    while (start < text.length) {
-      const end = Math.min(start + this.chunkSize, text.length);
-      chunks.push({
-        content: text.slice(start, end),
-        chunkIndex: chunks.length,
-        totalChunks: 0,
-        startOffset: start,
-        endOffset: end,
-      });
-      start += step;
-      if (end === text.length) break;
-    }
-
-    // Set totalChunks
-    for (const chunk of chunks) {
-      chunk.totalChunks = chunks.length;
-    }
-
-    return chunks;
-  }
-}

package/src/services/code-graph.service.test.ts

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm, readFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { CodeGraphService } from './code-graph.service.js';
-import { createStoreId } from '../types/brands.js';
-
-describe('CodeGraphService', () => {
-  let tempDir: string;
-  let service: CodeGraphService;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'code-graph-test-'));
-    service = new CodeGraphService(tempDir);
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe('buildGraph', () => {
-    it('should build a graph from TypeScript files', async () => {
-      const files = [
-        {
-          path: '/src/utils.ts',
-          content: `
-export function helper() {
-  return 'help';
-}
-
-export function doWork() {
-  helper();
-  return 'done';
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-      const nodes = graph.getAllNodes();
-
-      expect(nodes.length).toBe(2);
-      expect(nodes.some((n) => n.name === 'helper')).toBe(true);
-      expect(nodes.some((n) => n.name === 'doWork')).toBe(true);
-    });
-
-    it('should track function calls', async () => {
-      const files = [
-        {
-          path: '/src/main.ts',
-          content: `
-function caller() {
-  callee();
-}
-
-function callee() {
-  return 42;
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-
-      // Check that caller calls callee
-      const callerEdges = graph.getEdges('/src/main.ts:caller');
-      const callsCallee = callerEdges.some((e) => e.to.includes('callee') && e.type === 'calls');
-      expect(callsCallee).toBe(true);
-    });
-
-    it('should track imports', async () => {
-      const files = [
-        {
-          path: '/src/consumer.ts',
-          content: `
-import { helper } from './utils.js';
-
-function useHelper() {
-  helper();
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-      const consumerEdges = graph.getEdges('/src/consumer.ts');
-      const hasImport = consumerEdges.some((e) => e.type === 'imports');
-      expect(hasImport).toBe(true);
-    });
-
-    it('should skip non-TypeScript/JavaScript files', async () => {
-      const files = [
-        { path: '/src/readme.md', content: '# README\n\nThis is docs.' },
-        { path: '/src/config.json', content: '{"key": "value"}' },
-        { path: '/src/main.ts', content: 'export function main() {}' },
-      ];
-
-      const graph = await service.buildGraph(files);
-      const nodes = graph.getAllNodes();
-
-      // Only the .ts file should have nodes
-      expect(nodes.length).toBe(1);
-      expect(nodes[0].name).toBe('main');
-    });
-  });
-
-  describe('saveGraph / loadGraph', () => {
-    it('should save and load a graph', async () => {
-      const storeId = createStoreId('test-store');
-      const files = [
-        {
-          path: '/src/utils.ts',
-          content: `
-export function helper() {
-  return 'help';
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-      await service.saveGraph(storeId, graph);
-
-      // Clear cache to force load from disk
-      service.clearCache();
-
-      const loadedGraph = await service.loadGraph(storeId);
-      expect(loadedGraph).not.toBeUndefined();
-
-      const nodes = loadedGraph!.getAllNodes();
-      expect(nodes.length).toBe(1);
-      expect(nodes[0].name).toBe('helper');
-    });
-
-    it('should return undefined for non-existent graph', async () => {
-      const storeId = createStoreId('non-existent');
-      const graph = await service.loadGraph(storeId);
-      expect(graph).toBeUndefined();
-    });
-
-    it('should cache loaded graphs', async () => {
-      const storeId = createStoreId('cached-store');
-      const files = [{ path: '/src/main.ts', content: 'export function main() {}' }];
-
-      const graph = await service.buildGraph(files);
-      await service.saveGraph(storeId, graph);
-
-      // Load twice - second should come from cache
-      const loaded1 = await service.loadGraph(storeId);
-      const loaded2 = await service.loadGraph(storeId);
-
-      // Should be the same instance from cache
-      expect(loaded1).toBe(loaded2);
-    });
-
-    it('should persist graph to JSON file', async () => {
-      const storeId = createStoreId('persisted-store');
-      const files = [{ path: '/src/main.ts', content: 'export function main() {}' }];
-
-      const graph = await service.buildGraph(files);
-      await service.saveGraph(storeId, graph);
-
-      // Check file exists
-      const graphPath = join(tempDir, 'graphs', `${storeId}.json`);
-      const content = await readFile(graphPath, 'utf-8');
-      const parsed = JSON.parse(content);
-
-      expect(parsed.nodes).toBeDefined();
-      expect(parsed.edges).toBeDefined();
-      expect(parsed.nodes.length).toBe(1);
-    });
-
-    it('should save and load a graph with class methods', async () => {
-      const storeId = createStoreId('class-methods-store');
-      const files = [
-        {
-          path: '/src/calculator.ts',
-          content: `
-export class Calculator {
-  add(a: number, b: number): number {
-    return a + b;
-  }
-
-  subtract(a: number, b: number): number {
-    return a - b;
-  }
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-      await service.saveGraph(storeId, graph);
-
-      // Clear cache to force load from disk
-      service.clearCache();
-
-      const loadedGraph = await service.loadGraph(storeId);
-      expect(loadedGraph).not.toBeUndefined();
-
-      const nodes = loadedGraph!.getAllNodes();
-      // Should have class + 2 methods
-      const classNode = nodes.find((n) => n.name === 'Calculator' && n.type === 'class');
-      const methodNodes = nodes.filter((n) => n.type === 'method');
-
-      expect(classNode).toBeDefined();
-      expect(methodNodes.length).toBe(2);
-      expect(methodNodes.some((m) => m.name === 'add')).toBe(true);
-      expect(methodNodes.some((m) => m.name === 'subtract')).toBe(true);
-    });
-  });
-
-  describe('getUsageStats', () => {
-    it('should return calledBy and calls counts', async () => {
-      const files = [
-        {
-          path: '/src/main.ts',
-          content: `
-function caller() {
-  target();
-}
-
-function target() {
-  return 1;
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-
-      // target is called by caller
-      const targetStats = service.getUsageStats(graph, '/src/main.ts', 'target');
-      expect(targetStats.calledBy).toBeGreaterThanOrEqual(1);
-
-      // caller has outgoing calls
-      const callerStats = service.getUsageStats(graph, '/src/main.ts', 'caller');
-      expect(callerStats.calls).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('getRelatedCode', () => {
-    it('should return callers and callees', async () => {
-      const files = [
-        {
-          path: '/src/main.ts',
-          content: `
-function caller() {
-  target();
-}
-
-function target() {
-  callee();
-}
-
-function callee() {
-  return 1;
-}
-`,
-        },
-      ];
-
-      const graph = await service.buildGraph(files);
-      const related = service.getRelatedCode(graph, '/src/main.ts', 'target');
-
-      // target is called by caller (and possibly itself due to regex-based detection)
-      const callers = related.filter((r) => r.relationship === 'calls this');
-      expect(callers.length).toBeGreaterThanOrEqual(1);
-      expect(callers.some((c) => c.id.includes('caller'))).toBe(true);
-
-      // target calls callee
-      const callees = related.filter((r) => r.relationship === 'called by this');
-      expect(callees.length).toBeGreaterThanOrEqual(1);
-      expect(callees.some((c) => c.id.includes('callee'))).toBe(true);
-    });
-  });
-
-  describe('clearCache', () => {
-    it('should clear cached graphs', async () => {
-      const storeId = createStoreId('cache-test');
-      const files = [{ path: '/src/main.ts', content: 'export function main() {}' }];
-
-      const graph = await service.buildGraph(files);
-      await service.saveGraph(storeId, graph);
-
-      // Load to populate cache
-      const loaded1 = await service.loadGraph(storeId);
-
-      // Clear cache
-      service.clearCache();
-
-      // Load again - should be different instance
-      const loaded2 = await service.loadGraph(storeId);
-
-      expect(loaded1).not.toBe(loaded2);
-    });
-  });
-});