devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/index/VectorStore.js

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

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { FilesystemService } from './filesystem/filesystem.service.js';
+export { RepositoryScanner, ScanOptions } from './analysis/scanner.js';
+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';
+export { GitAnalyzer } from './analysis/analyzers/git.analyzer.js';
+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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/index.js

@@ -0,0 +1,29 @@
+// Public API exports for @devbrain/core
+export { FilesystemService } from './filesystem/filesystem.service.js';
+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';
+export { TsconfigAnalyzer } from './analysis/analyzers/tsconfig.analyzer.js';
+export { GitAnalyzer } from './analysis/analyzers/git.analyzer.js';
+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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/memory/memory.service.d.ts

@@ -0,0 +1,22 @@
+import { AggregatedAnalysis } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class MemoryService {
+    private readonly fsService;
+    constructor(fsService?: FilesystemService);
+    /**
+     * 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;
+    private buildFeatures;
+    private buildRules;
+    private buildTimeline;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/memory/memory.service.js

@@ -0,0 +1,338 @@
+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';
+export class MemoryService {
+    fsService;
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    /**
+     * 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);
+        const features = this.buildFeatures(analysis);
+        const rules = this.buildRules(analysis);
+        const timeline = this.buildTimeline(analysis);
+        await this.fsService.write(join(memoryDir, 'summary.md'), summary);
+        await this.fsService.write(join(memoryDir, 'stack.md'), stack);
+        await this.fsService.write(join(memoryDir, 'architecture.md'), architecture);
+        await this.fsService.write(join(memoryDir, 'features.md'), features);
+        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'] || {};
+        const overview = readmeData.description || 'No project description available.';
+        const projectName = analysis.projectName || packageJsonData.name || 'unnamed-project';
+        const fileList = [...analysis.files].sort();
+        const treeLines = fileList.map((f) => `- ${f}`).join('\n');
+        return [
+            `# Project Summary: ${projectName}`,
+            '',
+            '## Overview',
+            overview,
+            '',
+            '## Repository Structure',
+            `Total Files Tracked: ${analysis.files.length}`,
+            '',
+            treeLines,
+            '',
+        ].join('\n');
+    }
+    buildStack(analysis) {
+        const techList = [...analysis.technologies]
+            .sort()
+            .map((t) => `- **${t}**`)
+            .join('\n') || '- None detected';
+        const fwList = [...analysis.frameworks]
+            .sort()
+            .map((f) => `- **${f}**`)
+            .join('\n') || '- None detected';
+        return [
+            '# Technology Stack',
+            '',
+            '## Core Languages & Runtimes',
+            techList,
+            '',
+            '## Frameworks & Libraries',
+            fwList,
+            '',
+        ].join('\n');
+    }
+    buildArchitecture(analysis) {
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const dockerfileData = analysis.analyzers.dockerfile || {};
+        const backendTech = analysis.technologies.includes('Node.js') ? 'Node.js' : 'unknown';
+        const buildTool = packageJsonData.dependencies ? 'npm' : 'unknown';
+        const dockerBase = dockerfileData.baseImage
+            ? `Docker (Base image: ${dockerfileData.baseImage})`
+            : 'None detected';
+        return [
+            '# Project Architecture',
+            '',
+            '## Layers & Runtimes',
+            `- **Backend Runtime**: ${backendTech}`,
+            `- **Build / Package Manager**: ${buildTool}`,
+            `- **Containerization / Deployment**: ${dockerBase}`,
+            '',
+            '## Module System & Standards',
+            `- **Primary Language**: ${analysis.metadata.projectLanguage || 'unknown'}`,
+            `- **Default Framework**: ${analysis.metadata.projectFramework || 'None'}`,
+            '',
+        ].join('\n');
+    }
+    buildFeatures(analysis) {
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const scripts = packageJsonData.scripts || [];
+        const features = [];
+        const files = analysis.files;
+        if (files.some((f) => f.includes('controller')))
+            features.push('Controller layer (business routing)');
+        if (files.some((f) => f.includes('route')))
+            features.push('API routing definition');
+        if (files.some((f) => f.includes('component') || f.includes('view')))
+            features.push('UI components / presentation layer');
+        if (files.some((f) => f.includes('service') || f.includes('provider')))
+            features.push('Service integrations / business logic');
+        if (files.some((f) => f.includes('model') || f.includes('entity')))
+            features.push('Data models / entity schemas');
+        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 = Object.keys(scripts).map((s) => `- \`npm run ${s}\``).join('\n') || '- None declared';
+        return [
+            '# Product Features',
+            '',
+            '## Codebase Feature Capabilities',
+            featureList,
+            '',
+            '## Runnable Project Commands',
+            scriptsList,
+            '',
+        ].join('\n');
+    }
+    buildRules(analysis) {
+        const tsconfigData = analysis.analyzers.tsconfig || {};
+        const rules = [
+            '# Project Coding Rules & Conventions',
+            '',
+            '## Compiler Options & Code Style Standards',
+        ];
+        if (tsconfigData.target) {
+            rules.push(`- **TypeScript Target**: ${tsconfigData.target}`);
+            rules.push(`- **Module System**: ${tsconfigData.module}`);
+            rules.push(`- **Strict Type Checking**: ${tsconfigData.strict ? 'Enabled' : 'Disabled'}`);
+            rules.push(`- **JSX Engine**: ${tsconfigData.jsx}`);
+        }
+        else {
+            rules.push('- No TypeScript rules detected. Applying default ES rules.');
+        }
+        rules.push('', '## General Architecture Rules', '- Enforce clean boundaries: CLI layer -> Core layer -> Shared utility layer.', '- Modular composition preferred over inheritance patterns.', '');
+        return rules.join('\n');
+    }
+    buildTimeline(analysis) {
+        const gitData = analysis.analyzers.git || {};
+        const commits = gitData.recentCommits || [];
+        const commitLines = commits.map((c) => `- **${c.hash}** - ${c.message} (${c.author})`).join('\n') ||
+            '- No commits found or git history unavailable';
+        const branch = gitData.branch || 'unknown';
+        return [
+            '# Project Timeline & History',
+            '',
+            '## Git Metrics',
+            `- **Current Branch**: ${branch}`,
+            '',
+            '## Recent Commit Log',
+            commitLines,
+            '',
+        ].join('\n');
+    }
+}
+//# sourceMappingURL=memory.service.js.map

package/dist/temp-prefix/node_modules/devbrain-cli/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;
+}