devbrain-cli 0.1.0 → 0.3.0

package/node_modules/@devbrain/core/dist/index/VectorIndexer.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+export class VectorIndexer {
+    vectorStore;
+    embeddingProvider;
+    constructor(vectorStore, embeddingProvider) {
+        this.vectorStore = vectorStore;
+        this.embeddingProvider = embeddingProvider;
+    }
+    hashText(text) {
+        return crypto.createHash('sha256').update(text).digest('hex');
+    }
+    parseMarkdown(filePath, memoryId) {
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const chunks = [];
+        let currentSectionHeader = '';
+        let currentSectionLines = [];
+        const flushSection = (nextHeader) => {
+            // Clean header name (e.g., "## Authentication" -> "Authentication")
+            const headerTitle = currentSectionHeader.replace(/^#+\s+/, '').trim();
+            const NOISY_SECTIONS = [
+                'Folder Structure',
+                'Recent Changes',
+                'Repository Structure',
+                'Recent Commit Log',
+                'Git Metrics'
+            ];
+            if (NOISY_SECTIONS.includes(headerTitle)) {
+                currentSectionHeader = nextHeader;
+                currentSectionLines = [];
+                return;
+            }
+            if (currentSectionLines.length > 0 || headerTitle) {
+                const sectionText = [currentSectionHeader, ...currentSectionLines]
+                    .filter(Boolean)
+                    .join('\n')
+                    .trim();
+                const sectionId = this.hashText(`${memoryId}:section:${headerTitle || 'General'}`);
+                if (sectionText) {
+                    chunks.push({
+                        id: sectionId,
+                        memoryId,
+                        parentId: null,
+                        level: 'section',
+                        text: sectionText,
+                        textHash: this.hashText(sectionText),
+                        metadata: {
+                            title: headerTitle || 'General',
+                            filePath: memoryId
+                        }
+                    });
+                }
+                // Parse bullets and paragraphs inside the section
+                let bulletIdx = 0;
+                let currentParagraph = '';
+                const flushParagraph = () => {
+                    if (currentParagraph.trim()) {
+                        const bulletText = currentParagraph.trim();
+                        const bulletId = this.hashText(`${memoryId}:bullet:${sectionId}:${bulletIdx}:${bulletText}`);
+                        chunks.push({
+                            id: bulletId,
+                            memoryId,
+                            parentId: sectionId,
+                            level: 'bullet',
+                            text: bulletText,
+                            textHash: this.hashText(bulletText),
+                            metadata: {
+                                sectionTitle: headerTitle || 'General',
+                                filePath: memoryId,
+                                index: bulletIdx
+                            }
+                        });
+                        bulletIdx++;
+                        currentParagraph = '';
+                    }
+                };
+                for (const line of currentSectionLines) {
+                    const trimmed = line.trim();
+                    if (!trimmed) {
+                        flushParagraph();
+                        continue;
+                    }
+                    // Check if list item
+                    const listMatch = trimmed.match(/^([*\-+]|\d+\.)\s+(.*)/);
+                    if (listMatch) {
+                        flushParagraph();
+                        const bulletText = listMatch[2].trim();
+                        const bulletId = this.hashText(`${memoryId}:bullet:${sectionId}:${bulletIdx}:${bulletText}`);
+                        chunks.push({
+                            id: bulletId,
+                            memoryId,
+                            parentId: sectionId,
+                            level: 'bullet',
+                            text: trimmed,
+                            textHash: this.hashText(trimmed),
+                            metadata: {
+                                sectionTitle: headerTitle || 'General',
+                                filePath: memoryId,
+                                index: bulletIdx
+                            }
+                        });
+                        bulletIdx++;
+                    }
+                    else {
+                        currentParagraph += (currentParagraph ? ' ' : '') + trimmed;
+                    }
+                }
+                flushParagraph();
+            }
+            currentSectionHeader = nextHeader;
+            currentSectionLines = [];
+        };
+        for (const line of lines) {
+            if (line.startsWith('#')) {
+                flushSection(line.trim());
+            }
+            else {
+                currentSectionLines.push(line);
+            }
+        }
+        flushSection('');
+        return chunks;
+    }
+    async indexMemory(filePath, memoryId) {
+        this.vectorStore.initialize();
+        const parsedChunks = this.parseMarkdown(filePath, memoryId);
+        if (parsedChunks.length === 0)
+            return;
+        // Load existing database state for this file
+        const existing = await this.vectorStore.getAllChunksForMemory(memoryId);
+        const existingMap = new Map(existing.map(e => [e.id, e.textHash]));
+        const chunksToUpsert = [];
+        const activeIds = new Set();
+        for (const chunk of parsedChunks) {
+            activeIds.add(chunk.id);
+            const existingHash = existingMap.get(chunk.id);
+            if (existingHash === chunk.textHash) {
+                // Skip unchanged
+                continue;
+            }
+            chunksToUpsert.push(chunk);
+        }
+        // Embed new/changed chunks
+        if (chunksToUpsert.length > 0) {
+            const texts = chunksToUpsert.map(c => c.text);
+            const embeddings = await this.embeddingProvider.generateEmbeddings(texts);
+            for (let i = 0; i < chunksToUpsert.length; i++) {
+                chunksToUpsert[i].embedding = embeddings[i];
+                chunksToUpsert[i].metadata = JSON.stringify(chunksToUpsert[i].metadata);
+            }
+            await this.vectorStore.upsertChunks(chunksToUpsert);
+        }
+        // Delete stale chunks
+        const idsToDelete = [];
+        for (const { id } of existing) {
+            if (!activeIds.has(id)) {
+                idsToDelete.push(id);
+            }
+        }
+        if (idsToDelete.length > 0) {
+            await this.vectorStore.deleteChunks(idsToDelete);
+        }
+    }
+}
+//# sourceMappingURL=VectorIndexer.js.map

package/node_modules/@devbrain/core/dist/index/VectorStore.d.ts

@@ -0,0 +1,26 @@
+export interface VectorChunk {
+    id: string;
+    memoryId: string;
+    parentId: string | null;
+    level: 'section' | 'bullet';
+    text: string;
+    textHash: string;
+    embedding: number[];
+    metadata: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface VectorStore {
+    initialize(): void;
+    upsertChunks(chunks: VectorChunk[]): Promise<void>;
+    deleteChunks(ids: string[]): Promise<void>;
+    getChunksByHash(ids: string[]): Promise<Map<string, string>>;
+    getAllChunksForMemory(memoryId: string): Promise<{
+        id: string;
+        textHash: string;
+    }[]>;
+    search(queryEmbedding: number[]): Promise<VectorChunk[]>;
+    getChunkById(id: string): Promise<VectorChunk | null>;
+    clearAll(): Promise<void>;
+    close(): void;
+}

package/node_modules/@devbrain/core/dist/index/VectorStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VectorStore.js.map

package/node_modules/@devbrain/core/dist/index.d.ts

@@ -4,6 +4,12 @@ export { Analyzer } from './analysis/analyzer.interface.js';
 export { AnalyzerRegistry } from './analysis/analyzer.registry.js';
 export { MemoryService } from './memory/memory.service.js';
 export { ContextService } from './context/context.service.js';
+export { GitService } from './git/git.service.js';
+export { LockManager } from './engine/lock.manager.js';
+export { LoggerService } from './engine/logger.service.js';
+export { HistoryManager } from './engine/history.manager.js';
+export { DependencyResolver } from './engine/dependency.resolver.js';
+export { MemoryEngine } from './engine/memory.engine.js';
 export { ReadmeAnalyzer } from './analysis/analyzers/readme.analyzer.js';
 export { PackageJsonAnalyzer } from './analysis/analyzers/package-json.analyzer.js';
 export { TsconfigAnalyzer } from './analysis/analyzers/tsconfig.analyzer.js';
@@ -12,3 +18,12 @@ export { DockerfileAnalyzer } from './analysis/analyzers/docker.analyzer.js';
 export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.analyzer.js';
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
+export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';
+export { EmbeddingProvider } from './embeddings/EmbeddingProvider.js';
+export { TransformersProvider } from './embeddings/TransformersProvider.js';
+export { VectorChunk, VectorStore } from './index/VectorStore.js';
+export { SQLiteVectorStore } from './index/SQLiteVectorStore.js';
+export { VectorIndexer } from './index/VectorIndexer.js';
+export { RankingEngine, GitCommitInfo } from './retrieval/RankingEngine.js';
+export { RetrievedMemory, SemanticRetriever } from './retrieval/SemanticRetriever.js';
+export { ContextBuilder } from './retrieval/ContextBuilder.js';

package/node_modules/@devbrain/core/dist/index.js

@@ -4,6 +4,12 @@ export { RepositoryScanner } from './analysis/scanner.js';
 export { AnalyzerRegistry } from './analysis/analyzer.registry.js';
 export { MemoryService } from './memory/memory.service.js';
 export { ContextService } from './context/context.service.js';
+export { GitService } from './git/git.service.js';
+export { LockManager } from './engine/lock.manager.js';
+export { LoggerService } from './engine/logger.service.js';
+export { HistoryManager } from './engine/history.manager.js';
+export { DependencyResolver } from './engine/dependency.resolver.js';
+export { MemoryEngine } from './engine/memory.engine.js';
 // Concrete Analyzer exports
 export { ReadmeAnalyzer } from './analysis/analyzers/readme.analyzer.js';
 export { PackageJsonAnalyzer } from './analysis/analyzers/package-json.analyzer.js';
@@ -13,4 +19,11 @@ export { DockerfileAnalyzer } from './analysis/analyzers/docker.analyzer.js';
 export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.analyzer.js';
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
+export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';
+export { TransformersProvider } from './embeddings/TransformersProvider.js';
+export { SQLiteVectorStore } from './index/SQLiteVectorStore.js';
+export { VectorIndexer } from './index/VectorIndexer.js';
+export { RankingEngine } from './retrieval/RankingEngine.js';
+export { SemanticRetriever } from './retrieval/SemanticRetriever.js';
+export { ContextBuilder } from './retrieval/ContextBuilder.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@devbrain/core/dist/memory/memory.service.d.ts

@@ -1,8 +1,5 @@
 import { AggregatedAnalysis } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-/**
- * Service responsible for generating deterministic, human-readable markdown project documentation.
- */
 export declare class MemoryService {
     private readonly fsService;
     constructor(fsService?: FilesystemService);
@@ -10,6 +7,12 @@ export declare class MemoryService {
      * Generates memory markdown files and writes them to the specified directory.
      */
     generateMemory(analysis: AggregatedAnalysis, memoryDir: string): Promise<void>;
+    /**
+     * Section-based markdown writer to prevent redundant Git diffs.
+     */
+    private writeSectionBasedMarkdown;
+    private parseSections;
+    private buildProjectMemory;
     private buildSummary;
     private buildStack;
     private buildArchitecture;

package/node_modules/@devbrain/core/dist/memory/memory.service.js

@@ -1,8 +1,6 @@
-import { join } from 'node:path';
+import { join, dirname, basename } from 'node:path';
+import { PROJECT_MEMORY_FILE_NAME, CUSTOM_NOTES_FILE_NAME, } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-/**
- * Service responsible for generating deterministic, human-readable markdown project documentation.
- */
 export class MemoryService {
     fsService;
     constructor(fsService = new FilesystemService()) {
@@ -12,6 +10,24 @@ export class MemoryService {
      * Generates memory markdown files and writes them to the specified directory.
      */
     async generateMemory(analysis, memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const projectMemoryPath = join(targetDir, PROJECT_MEMORY_FILE_NAME);
+        const customNotesPath = join(targetDir, CUSTOM_NOTES_FILE_NAME);
+        // Ensure custom_notes.md exists
+        if (!(await this.fsService.exists(customNotesPath))) {
+            const defaultCustomNotes = [
+                '# Custom Developer Notes',
+                '',
+                'Use this file to document manual project conventions, architecture diagrams, decision logs, or any other notes.',
+                'This file will NEVER be overwritten by DevBrain.',
+                '',
+            ].join('\n');
+            await this.fsService.write(customNotesPath, defaultCustomNotes);
+        }
+        // Build the new unified project memory contents
+        const newMarkdown = this.buildProjectMemory(analysis);
+        await this.writeSectionBasedMarkdown(projectMemoryPath, newMarkdown);
+        // Generate legacy v0.1 files inside memoryDir for 100% backward compatibility
         const summary = this.buildSummary(analysis);
         const stack = this.buildStack(analysis);
         const architecture = this.buildArchitecture(analysis);
@@ -25,6 +41,171 @@ export class MemoryService {
         await this.fsService.write(join(memoryDir, 'rules.md'), rules);
         await this.fsService.write(join(memoryDir, 'timeline.md'), timeline);
     }
+    /**
+     * Section-based markdown writer to prevent redundant Git diffs.
+     */
+    async writeSectionBasedMarkdown(filePath, newContent) {
+        if (!(await this.fsService.exists(filePath))) {
+            await this.fsService.write(filePath, newContent);
+            return;
+        }
+        try {
+            const oldContent = await this.fsService.read(filePath);
+            const oldSections = this.parseSections(oldContent);
+            const newSections = this.parseSections(newContent);
+            let hasChanges = false;
+            const updatedSections = [];
+            const oldPreamble = oldSections.get('__PREAMBLE__') || '';
+            const newPreamble = newSections.get('__PREAMBLE__') || '';
+            if (oldPreamble !== newPreamble) {
+                hasChanges = true;
+            }
+            updatedSections.push(newPreamble);
+            for (const [header, newSecContent] of newSections.entries()) {
+                if (header === '__PREAMBLE__')
+                    continue;
+                const oldSecContent = oldSections.get(header);
+                if (oldSecContent !== newSecContent) {
+                    hasChanges = true;
+                }
+                updatedSections.push(newSecContent);
+            }
+            for (const oldHeader of oldSections.keys()) {
+                if (oldHeader !== '__PREAMBLE__' && !newSections.has(oldHeader)) {
+                    hasChanges = true;
+                }
+            }
+            if (hasChanges) {
+                const compiled = updatedSections.join('\n').trim() + '\n';
+                await this.fsService.writeAtomic(filePath, compiled);
+            }
+        }
+        catch {
+            await this.fsService.writeAtomic(filePath, newContent);
+        }
+    }
+    parseSections(content) {
+        const sections = new Map();
+        const parts = content.split(/\n(?=## )/);
+        let preamble = '';
+        for (const part of parts) {
+            if (part.startsWith('## ') || part.trim().startsWith('## ')) {
+                const lines = part.trim().split('\n');
+                const header = lines[0].trim();
+                sections.set(header, part);
+            }
+            else {
+                preamble = part;
+            }
+        }
+        if (preamble) {
+            sections.set('__PREAMBLE__', preamble);
+        }
+        return sections;
+    }
+    buildProjectMemory(analysis) {
+        const readmeData = analysis.analyzers.readme || {};
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const tsconfigData = analysis.analyzers.tsconfig || {};
+        const gitData = analysis.analyzers.git || {};
+        const dockerfileData = analysis.analyzers.dockerfile || {};
+        const sourceCodeData = analysis.analyzers['source-code'] || {};
+        const overview = readmeData.description || 'No project description available.';
+        const projectName = analysis.projectName || packageJsonData.name || 'unnamed-project';
+        const fileList = [...analysis.files].sort();
+        const treeLines = fileList.slice(0, 100).map((f) => `- \`${f}\``).join('\n') +
+            (fileList.length > 100 ? `\n- *...and ${fileList.length - 100} more files*` : '');
+        const techList = [...analysis.technologies]
+            .sort()
+            .map((t) => `- **${t}**`)
+            .join('\n') || '- None detected';
+        const fwList = [...analysis.frameworks]
+            .sort()
+            .map((f) => `- **${f}**`)
+            .join('\n') || '- None detected';
+        const modulesList = (sourceCodeData.modules || [])
+            .map((m) => `- \`${m.filePath}\` - **${m.name}** (${m.type})`)
+            .join('\n') || '- No source modules analyzed.';
+        const apisList = (sourceCodeData.apis || [])
+            .map((a) => `- **${a.method}** \`${a.path}\` (defined in \`${a.file}\`)`)
+            .join('\n') || '- No API endpoints detected.';
+        const dbList = (sourceCodeData.databaseEntities || [])
+            .map((d) => `- **${d}**`)
+            .join('\n') || '- No entities or model schemas detected.';
+        const authList = (sourceCodeData.authMethods || [])
+            .map((a) => `- **${a}**`)
+            .join('\n') || '- No explicit auth pattern identified (defaults to basic credentials/tokens).';
+        const extList = (sourceCodeData.externalServices || [])
+            .map((e) => `- **${e}**`)
+            .join('\n') || '- No third-party API integrations detected.';
+        const tsconfigOptions = tsconfigData.target
+            ? [
+                `- **TypeScript Target**: ${tsconfigData.target}`,
+                `- **Module System**: ${tsconfigData.module}`,
+                `- **Strict Mode**: ${tsconfigData.strict ? 'Enabled' : 'Disabled'}`,
+            ].join('\n')
+            : '- Standard JavaScript style conventions apply.';
+        const commits = gitData.recentCommits || [];
+        const commitLines = commits
+            .map((c) => `- **${c.hash}** - ${c.message} (${c.author})`)
+            .join('\n') || '- No commits found or git history unavailable';
+        return [
+            '<!-- ⚠️ THIS FILE IS AUTO-GENERATED BY DEVBRAIN. -->',
+            '<!-- DO NOT EDIT. YOUR CHANGES WILL BE OVERWRITTEN. -->',
+            '',
+            `# Project Memory: ${projectName}`,
+            '',
+            '## Project Overview',
+            overview,
+            '',
+            '## Tech Stack',
+            '### Core Languages & Runtimes',
+            techList,
+            '',
+            '### Frameworks & Libraries',
+            fwList,
+            '',
+            '## Folder Structure',
+            `Total Files Tracked: ${analysis.files.length}`,
+            '',
+            treeLines,
+            '',
+            '## Features',
+            '- Scan file structures recursively',
+            '- Map project dependencies',
+            '- Perform incremental parsing on change commit events',
+            '',
+            '## Modules',
+            modulesList,
+            '',
+            '## APIs',
+            apisList,
+            '',
+            '## Database',
+            dbList,
+            '',
+            '## Authentication',
+            authList,
+            '',
+            '## External Services',
+            extList,
+            '',
+            '## Configuration',
+            `- Container base image: ${dockerfileData.baseImage || 'None'}`,
+            `- Package version: ${packageJsonData.version || '0.0.1'}`,
+            '',
+            '## Coding Standards',
+            tsconfigOptions,
+            '',
+            '## Recent Changes',
+            commitLines,
+            '',
+            '## Custom Notes',
+            `See [custom_notes.md](${CUSTOM_NOTES_FILE_NAME}) for hand-written notes.`,
+            '',
+        ].join('\n');
+    }
+    // Legacy generators for 100% backward compatibility
     buildSummary(analysis) {
         const readmeData = analysis.analyzers.readme || {};
         const packageJsonData = analysis.analyzers['package-json'] || {};
@@ -90,7 +271,6 @@ export class MemoryService {
     buildFeatures(analysis) {
         const packageJsonData = analysis.analyzers['package-json'] || {};
         const scripts = packageJsonData.scripts || [];
-        // Scan file paths to infer feature areas
         const features = [];
         const files = analysis.files;
         if (files.some((f) => f.includes('controller')))
@@ -106,7 +286,7 @@ export class MemoryService {
         if (files.some((f) => f.includes('tests/') || f.endsWith('.test.ts') || f.endsWith('.spec.ts')))
             features.push('Unit/Integration Testing suite');
         const featureList = features.map((f) => `- ${f}`).join('\n') || '- Basic codebase files structure';
-        const scriptsList = scripts.map((s) => `- \`npm run ${s}\``).join('\n') || '- None declared';
+        const scriptsList = Object.keys(scripts).map((s) => `- \`npm run ${s}\``).join('\n') || '- None declared';
         return [
             '# Product Features',
             '',

package/node_modules/@devbrain/core/dist/retrieval/ContextBuilder.d.ts

@@ -0,0 +1,4 @@
+import { RetrievedMemory } from './SemanticRetriever.js';
+export declare class ContextBuilder {
+    buildContext(query: string, results: RetrievedMemory[]): string;
+}

package/node_modules/@devbrain/core/dist/retrieval/ContextBuilder.js

@@ -0,0 +1,107 @@
+export class ContextBuilder {
+    buildContext(query, results) {
+        if (results.length === 0) {
+            return [
+                '# DEVBRAIN AI CONTEXT (SEMANTIC SEARCH)',
+                '',
+                `Query: "${query}"`,
+                '',
+                'No matching local memories found.',
+            ].join('\n');
+        }
+        const lines = [];
+        lines.push('<!-- START OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        lines.push('# DEVBRAIN AI CONTEXT (SEMANTIC SEARCH)');
+        lines.push('');
+        lines.push(`Query: "${query}"`);
+        lines.push('');
+        lines.push('The following local memories were retrieved as highly relevant to your query:');
+        lines.push('');
+        const grouped = new Map();
+        const sectionsDirectlyMatched = [];
+        for (const res of results) {
+            const chunk = res.chunk;
+            if (chunk.level === 'section') {
+                sectionsDirectlyMatched.push(res);
+            }
+            else {
+                const parentId = chunk.parentId || 'orphan';
+                let parentTitle = 'General';
+                let parentText = '';
+                const memoryId = chunk.memoryId;
+                if (res.parentSection) {
+                    parentText = res.parentSection.text;
+                    try {
+                        const meta = JSON.parse(res.parentSection.metadata);
+                        parentTitle = meta.title || 'General';
+                    }
+                    catch { }
+                }
+                else {
+                    try {
+                        const meta = JSON.parse(chunk.metadata);
+                        parentTitle = meta.sectionTitle || 'General';
+                    }
+                    catch { }
+                }
+                const existing = grouped.get(parentId);
+                if (existing) {
+                    existing.maxScore = Math.max(existing.maxScore, res.score);
+                    if (!existing.bullets.includes(chunk.text)) {
+                        existing.bullets.push(chunk.text);
+                    }
+                }
+                else {
+                    grouped.set(parentId, {
+                        sectionTitle: parentTitle,
+                        memoryId,
+                        sectionText: parentText,
+                        maxScore: res.score,
+                        bullets: [chunk.text]
+                    });
+                }
+            }
+        }
+        if (sectionsDirectlyMatched.length > 0) {
+            lines.push('## SECTION LEVEL MATCHES');
+            lines.push('');
+            for (const sec of sectionsDirectlyMatched) {
+                let title = 'General';
+                try {
+                    const meta = JSON.parse(sec.chunk.metadata);
+                    title = meta.title || 'General';
+                }
+                catch { }
+                lines.push(`### Section: ${title} (Score: ${sec.score})`);
+                lines.push(`Source: \`${sec.chunk.memoryId}\``);
+                lines.push('');
+                lines.push(sec.chunk.text);
+                lines.push('');
+            }
+        }
+        if (grouped.size > 0) {
+            lines.push('## DETAILED CONTEXT MATCHES');
+            lines.push('');
+            for (const [_, val] of grouped.entries()) {
+                lines.push(`### Section: ${val.sectionTitle} (Max Bullet Score: ${val.maxScore})`);
+                lines.push(`Source: \`${val.memoryId}\``);
+                lines.push('');
+                if (val.sectionText) {
+                    lines.push('#### Expanded Context:');
+                    lines.push('```markdown');
+                    lines.push(val.sectionText);
+                    lines.push('```');
+                    lines.push('');
+                }
+                lines.push('#### Exact Semantic Matches:');
+                for (const bullet of val.bullets) {
+                    lines.push(`- ${bullet}`);
+                }
+                lines.push('');
+            }
+        }
+        lines.push('<!-- END OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=ContextBuilder.js.map

package/node_modules/@devbrain/core/dist/retrieval/RankingEngine.d.ts

@@ -0,0 +1,13 @@
+import { DevBrainConfig } from '@devbrain/shared';
+import { VectorChunk } from '../index/VectorStore.js';
+export interface GitCommitInfo {
+    hash: string;
+    message: string;
+}
+export declare const CATEGORY_WEIGHTS: Record<string, number>;
+export declare class RankingEngine {
+    private config;
+    constructor(config: DevBrainConfig);
+    getCategory(chunk: VectorChunk): string;
+    calculateScore(chunk: VectorChunk, recentCommits?: GitCommitInfo[]): number;
+}