devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.d.ts

@@ -0,0 +1,24 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export interface SourceModule {
+    filePath: string;
+    name: string;
+    type: 'service' | 'controller' | 'route' | 'model' | 'other';
+    classes: string[];
+    functions: string[];
+    imports: string[];
+}
+export interface SourceApi {
+    method: string;
+    path: string;
+    file: string;
+}
+export declare class SourceCodeAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "source-code";
+    readonly name = "Source Code Structure Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.js

@@ -0,0 +1,126 @@
+import { join, extname, basename } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export class SourceCodeAnalyzer {
+    fsService;
+    id = 'source-code';
+    name = 'Source Code Structure Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        // Supports if there are any TS/JS source files in the project list
+        return project.files.some((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist'));
+    }
+    async analyze(project) {
+        const modules = [];
+        const apis = [];
+        const databaseEntities = new Set();
+        const authMethods = new Set();
+        const externalServices = new Set();
+        // Process only TS/JS source files up to a reasonable limit (e.g. 500 files for speed)
+        const sourceFiles = project.files
+            .filter((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist') && !f.endsWith('.test.ts') && !f.endsWith('.spec.ts'))
+            .slice(0, 500);
+        for (const file of sourceFiles) {
+            try {
+                const fullPath = join(project.cwd, file);
+                const content = await this.fsService.read(fullPath);
+                const baseName = basename(file);
+                const ext = extname(file);
+                const nameWithoutExt = baseName.slice(0, -ext.length);
+                // 1. Determine Module Type
+                let type = 'other';
+                if (/controller/i.test(nameWithoutExt))
+                    type = 'controller';
+                else if (/service/i.test(nameWithoutExt))
+                    type = 'service';
+                else if (/route/i.test(nameWithoutExt))
+                    type = 'route';
+                else if (/model/i.test(nameWithoutExt) || /entity/i.test(nameWithoutExt))
+                    type = 'model';
+                // 2. Classes
+                const classes = [];
+                const classRegex = /class\s+([A-Za-z0-9_]+)/g;
+                let match;
+                while ((match = classRegex.exec(content)) !== null) {
+                    classes.push(match[1]);
+                    if (type === 'model') {
+                        databaseEntities.add(match[1]);
+                    }
+                }
+                // 3. Functions
+                const functions = [];
+                const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_]+)/g;
+                while ((match = funcRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                const arrowFuncRegex = /(?:const|let|var)\s+([A-Za-z0-9_]+)\s*=\s*(?:async\s*)?\((?:[^)]*)\)\s*=>/g;
+                while ((match = arrowFuncRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                // 4. Imports / External Services
+                const imports = [];
+                const importRegex = /(?:import|require)\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const importSource = match[1];
+                    imports.push(importSource);
+                    // Detect external service integrations
+                    if (['axios', 'stripe', 'twilio', 'aws-sdk', 'redis', '@google-cloud/'].some(s => importSource.includes(s))) {
+                        externalServices.add(importSource);
+                    }
+                }
+                // 5. API Endpoints
+                // Match express-like router: router.get('/path', ...) or app.post('/path', ...)
+                const expressApiRegex = /(?:app|router|route|express)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/gi;
+                while ((match = expressApiRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2],
+                        file,
+                    });
+                }
+                // Match NestJS decorators: @Get('/path') or @Post()
+                const nestApiDecoratorRegex = /@(Get|Post|Put|Delete|Patch)\s*\(\s*(?:['"]([^'"]+)['"])?/g;
+                while ((match = nestApiDecoratorRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2] || '/',
+                        file,
+                    });
+                }
+                // 6. Authentication detection
+                if (/jwt|passport|bcrypt|oauth|session|authHeader|bearer/i.test(content)) {
+                    if (content.includes('jwt') || content.includes('JWT'))
+                        authMethods.add('JWT');
+                    if (content.includes('oauth') || content.includes('OAuth'))
+                        authMethods.add('OAuth');
+                    if (content.includes('session'))
+                        authMethods.add('Session-based');
+                }
+                modules.push({
+                    filePath: file,
+                    name: nameWithoutExt,
+                    type,
+                    classes,
+                    functions: functions.slice(0, 15), // cap function list
+                    imports,
+                });
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                modules,
+                apis: apis.slice(0, 100), // cap API endpoints
+                databaseEntities: Array.from(databaseEntities),
+                authMethods: Array.from(authMethods),
+                externalServices: Array.from(externalServices),
+            },
+        };
+    }
+}
+//# sourceMappingURL=source-code.analyzer.js.map

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/analyzers/tsconfig.analyzer.d.ts

@@ -0,0 +1,14 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for tsconfig.json configurations.
+ */
+export declare class TsconfigAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "tsconfig";
+    readonly name = "TypeScript Configuration Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/analyzers/tsconfig.analyzer.js

@@ -0,0 +1,47 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for tsconfig.json configurations.
+ */
+export class TsconfigAnalyzer {
+    fsService;
+    id = 'tsconfig';
+    name = 'TypeScript Configuration Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'tsconfig.json');
+    }
+    async analyze(project) {
+        const tsconfigFile = project.files.find((f) => f === 'tsconfig.json');
+        const tsconfigPath = join(project.cwd, tsconfigFile);
+        const rawContent = await this.fsService.read(tsconfigPath);
+        // Strip comments to allow parsing json with comments
+        const cleanJson = rawContent.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').trim();
+        let compilerOptions = {};
+        let references = [];
+        try {
+            const parsed = JSON.parse(cleanJson);
+            compilerOptions = parsed.compilerOptions || {};
+            references = parsed.references || [];
+        }
+        catch {
+            // Fallback if parsing fails
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                target: compilerOptions.target || 'default',
+                module: compilerOptions.module || 'default',
+                moduleResolution: compilerOptions.moduleResolution || 'default',
+                strict: compilerOptions.strict ?? false,
+                jsx: compilerOptions.jsx || 'none',
+                referencesCount: references.length,
+                technologies: ['TypeScript'],
+            },
+        };
+    }
+}
+//# sourceMappingURL=tsconfig.analyzer.js.map

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

@@ -0,0 +1,21 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export interface ScanOptions {
+    ignore?: string[];
+    followSymlinks?: boolean;
+    respectGitignore?: boolean;
+}
+/**
+ * Service for scanning repositories and finding files while respecting configuration filters.
+ */
+export declare class RepositoryScanner {
+    private readonly fsService;
+    constructor(fsService?: FilesystemService);
+    /**
+     * Scans a workspace directory recursively and returns all matching relative file paths.
+     */
+    scan(cwd: string, options?: ScanOptions): Promise<string[]>;
+    /**
+     * Helper to translate standard .gitignore patterns into fast-glob rules.
+     */
+    private parseGitignore;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/scanner.js

@@ -0,0 +1,81 @@
+import fg from 'fast-glob';
+import { join } from 'node:path';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+import { DEFAULT_IGNORE_PATTERNS } from '@devbrain/shared';
+/**
+ * Service for scanning repositories and finding files while respecting configuration filters.
+ */
+export class RepositoryScanner {
+    fsService;
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    /**
+     * Scans a workspace directory recursively and returns all matching relative file paths.
+     */
+    async scan(cwd, options = {}) {
+        const ignoreList = [...(options.ignore || DEFAULT_IGNORE_PATTERNS)];
+        // Respect .gitignore if configured
+        if (options.respectGitignore !== false) {
+            const gitignorePath = join(cwd, '.gitignore');
+            if (await this.fsService.exists(gitignorePath)) {
+                try {
+                    const gitignoreContent = await this.fsService.read(gitignorePath);
+                    const gitignoreRules = this.parseGitignore(gitignoreContent);
+                    ignoreList.push(...gitignoreRules);
+                }
+                catch {
+                    // Fallback silently if gitignore reading fails
+                }
+            }
+        }
+        // fast-glob parameters
+        const files = await fg('**/*', {
+            cwd,
+            ignore: ignoreList,
+            followSymbolicLinks: options.followSymlinks ?? false,
+            dot: true, // Scan hidden files like .gitignore or .git
+            onlyFiles: true,
+        });
+        return files;
+    }
+    /**
+     * Helper to translate standard .gitignore patterns into fast-glob rules.
+     */
+    parseGitignore(content) {
+        const rules = [];
+        const lines = content.split(/\r?\n/);
+        for (let line of lines) {
+            line = line.trim();
+            // Skip empty lines and comments
+            if (!line || line.startsWith('#')) {
+                continue;
+            }
+            // Negative patterns are not directly handled by basic fast-glob ignores,
+            // but simple exclusions are translated.
+            let pattern = line;
+            if (pattern.startsWith('!')) {
+                continue; // Skip negative ignores for simplicity in scanner v0.1
+            }
+            if (pattern.startsWith('/')) {
+                pattern = pattern.substring(1);
+            }
+            // If it has no slash and is not a wildcard, it can be anywhere in the directory hierarchy
+            if (!pattern.includes('/')) {
+                rules.push(`**/${pattern}`);
+                rules.push(`**/${pattern}/**`);
+            }
+            else {
+                if (pattern.endsWith('/')) {
+                    rules.push(`${pattern}**`);
+                }
+                else {
+                    rules.push(pattern);
+                    rules.push(`${pattern}/**`);
+                }
+            }
+        }
+        return rules;
+    }
+}
+//# sourceMappingURL=scanner.js.map

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

@@ -0,0 +1,16 @@
+import { AggregatedAnalysis } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class ContextService {
+    private readonly fsService;
+    constructor(fsService?: FilesystemService);
+    /**
+     * Generates and writes context.md to the target directory.
+     */
+    generateContext(analysis: AggregatedAnalysis, memoryDir: string): Promise<string>;
+    /**
+     * Reads project memory and compiles it into a single token-efficient string.
+     */
+    buildContext(memoryDir: string): Promise<string>;
+    private buildContextString;
+    private normalizeHeadings;
+}

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

@@ -0,0 +1,158 @@
+import { join, dirname, basename } from 'node:path';
+import { CONTEXT_FILE_NAME, MEMORY_FILE_NAME, ValidationError, } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class ContextService {
+    fsService;
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    /**
+     * Generates and writes context.md to the target directory.
+     */
+    async generateContext(analysis, memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const contextPath = join(targetDir, CONTEXT_FILE_NAME);
+        const contextContent = this.buildContextString(analysis);
+        const fileContent = [
+            '<!-- ⚠️ THIS FILE IS AUTO-GENERATED BY DEVBRAIN. -->',
+            '<!-- DO NOT EDIT. YOUR CHANGES WILL BE OVERWRITTEN. -->',
+            '',
+            contextContent,
+        ].join('\n');
+        await this.fsService.writeAtomic(contextPath, fileContent);
+        return contextContent;
+    }
+    /**
+     * Reads project memory and compiles it into a single token-efficient string.
+     */
+    async buildContext(memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const jsonPath = join(targetDir, MEMORY_FILE_NAME);
+        // If memory.json exists, build context from it
+        if (await this.fsService.exists(jsonPath)) {
+            try {
+                const analysis = await this.fsService.readJson(jsonPath);
+                return this.buildContextString(analysis);
+            }
+            catch {
+                // Fall back to folder scanning if parsing fails
+            }
+        }
+        // Ensure memory folder exists if memory.json is not present (backward compatibility check)
+        if (!(await this.fsService.exists(memoryDir))) {
+            throw new ValidationError('Project memory directory not found.', `The directory ${memoryDir} does not exist.`, 'Run "devbrain learn" to scan the repository and populate the memory files first.');
+        }
+        // Fallback: Read individual .md files (v0.1 structure)
+        const files = [
+            'summary.md',
+            'stack.md',
+            'architecture.md',
+            'features.md',
+            'rules.md',
+            'timeline.md',
+        ];
+        const parts = [];
+        parts.push('<!-- START OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        parts.push('# DEVBRAIN PROJECT CONTEXT INDEX');
+        parts.push('');
+        for (const file of files) {
+            const filePath = join(memoryDir, file);
+            if (!(await this.fsService.exists(filePath))) {
+                continue;
+            }
+            const content = await this.fsService.read(filePath);
+            const formatted = this.normalizeHeadings(file, content);
+            parts.push(formatted);
+            parts.push('');
+        }
+        parts.push('<!-- END OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
+        return parts.join('\n');
+    }
+    buildContextString(analysis) {
+        const readmeData = analysis.analyzers.readme || {};
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const tsconfigData = analysis.analyzers.tsconfig || {};
+        const gitData = analysis.analyzers.git || {};
+        const sourceCodeData = analysis.analyzers['source-code'] || {};
+        const projectName = analysis.projectName || packageJsonData.name || 'unnamed-project';
+        const overview = readmeData.description || 'No description available.';
+        const filesCount = analysis.files.length;
+        const keyFiles = analysis.files.filter((f) => f.includes('package.json') ||
+            f.includes('tsconfig.json') ||
+            f.includes('routes') ||
+            f.includes('controller') ||
+            f.includes('service') ||
+            f.includes('model') ||
+            f.includes('entity')).slice(0, 30);
+        const modules = (sourceCodeData.modules || [])
+            .map((m) => `- Module: \`${m.name}\` (Type: ${m.type}, File: \`${m.filePath}\`)\n  Classes: [${m.classes.join(', ')}]\n  Functions: [${m.functions.join(', ')}]`)
+            .join('\n');
+        const apis = (sourceCodeData.apis || [])
+            .map((a) => `- ${a.method} ${a.path}`)
+            .join('\n');
+        const dbs = (sourceCodeData.databaseEntities || []).map((d) => `- Model: ${d}`).join('\n');
+        const auths = (sourceCodeData.authMethods || []).map((a) => `- Auth: ${a}`).join('\n');
+        const externals = (sourceCodeData.externalServices || []).map((e) => `- Service: ${e}`).join('\n');
+        const commits = (gitData.recentCommits || [])
+            .slice(0, 3)
+            .map((c) => `- [${c.hash}] ${c.message}`)
+            .join('\n');
+        return [
+            '# DEVBRAIN AI CONTEXT',
+            '',
+            `## Project: ${projectName}`,
+            overview,
+            '',
+            `## Tech Stack & Language`,
+            `- Core Languages: ${analysis.technologies.join(', ') || 'None detected'}`,
+            `- Frameworks: ${analysis.frameworks.join(', ') || 'None detected'}`,
+            `- TS Compiler Target: ${tsconfigData.target || 'N/A'}`,
+            `- Strict Mode: ${tsconfigData.strict ? 'Enabled' : 'Disabled'}`,
+            '',
+            '## Project Architecture & Modules',
+            modules || '- No specific source code modules identified.',
+            '',
+            '## API Endpoints',
+            apis || '- No routes detected.',
+            '',
+            '## Database & Schemas',
+            dbs || '- No database models identified.',
+            '',
+            '## Authentication Systems',
+            auths || '- Default token/credentials handling.',
+            '',
+            '## Third-Party Integrations',
+            externals || '- No external API integrations.',
+            '',
+            `## Repository Structure (${filesCount} total files)`,
+            'Important files:',
+            keyFiles.map((kf) => `- \`${kf}\``).join('\n') || '- No critical files highlighted.',
+            '',
+            '## Recent Changes',
+            commits || '- No git commit log available.',
+            '',
+        ].join('\n');
+    }
+    normalizeHeadings(fileName, content) {
+        const sectionName = fileName.replace('.md', '').toUpperCase();
+        const lines = content.split('\n');
+        const processedLines = [`## SECTION: ${sectionName}`, ''];
+        for (let line of lines) {
+            line = line.trimEnd();
+            if (line.startsWith('# ')) {
+                processedLines.push(`### ${line.substring(2)}`);
+            }
+            else if (line.startsWith('## ')) {
+                processedLines.push(`#### ${line.substring(3)}`);
+            }
+            else if (line.startsWith('### ')) {
+                processedLines.push(`##### ${line.substring(4)}`);
+            }
+            else {
+                processedLines.push(line);
+            }
+        }
+        return processedLines.join('\n').trim();
+    }
+}
+//# sourceMappingURL=context.service.js.map

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

@@ -0,0 +1,4 @@
+export interface EmbeddingProvider {
+    generateEmbedding(text: string): Promise<number[]>;
+    generateEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/embeddings/EmbeddingProvider.js

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

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

@@ -0,0 +1,9 @@
+import { EmbeddingProvider } from './EmbeddingProvider.js';
+export declare class TransformersProvider implements EmbeddingProvider {
+    private pipelineInstance;
+    private modelName;
+    constructor(modelName?: string);
+    private getPipeline;
+    generateEmbedding(text: string): Promise<number[]>;
+    generateEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/embeddings/TransformersProvider.js

@@ -0,0 +1,70 @@
+import os from 'node:os';
+import path from 'node:path';
+export class TransformersProvider {
+    pipelineInstance = null;
+    modelName;
+    constructor(modelName = 'onnx-community/all-MiniLM-L6-v2-ONNX') {
+        // We default to 'onnx-community/all-MiniLM-L6-v2-ONNX' or 'Xenova/all-MiniLM-L6-v2'
+        this.modelName = modelName;
+    }
+    async getPipeline() {
+        if (this.pipelineInstance) {
+            return this.pipelineInstance;
+        }
+        try {
+            // Lazy load @huggingface/transformers
+            const { pipeline, env } = await import('@huggingface/transformers');
+            // Configure transformers cache globally
+            const globalDevBrainHome = path.join(os.homedir(), '.devbrain');
+            const cacheDir = path.join(globalDevBrainHome, 'models');
+            env.cacheDir = cacheDir;
+            // Prevent remote model downloads from hanging in test environments
+            if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+                throw new Error('Network connection disabled in test environment.');
+            }
+            // Feature extraction pipeline
+            this.pipelineInstance = await pipeline('feature-extraction', this.modelName);
+            return this.pipelineInstance;
+        }
+        catch (error) {
+            const msg = error.message || '';
+            let errorType = 'Embedding Model Load Failure';
+            let diagnostics = 'Ensure you have an active internet connection for the first run, or that the model is present in the cache.';
+            if (msg.includes('Unauthorized') || msg.includes('401') || msg.includes('forbidden')) {
+                errorType = 'Authentication Error';
+                diagnostics = 'The model repository appears to be private, requires authentication tokens, or is unauthorized.';
+            }
+            else if (msg.includes('404') || msg.includes('not found') || msg.includes('Cannot find')) {
+                errorType = 'Invalid Model Identifier';
+                diagnostics = `The model repository '${this.modelName}' does not exist on Hugging Face. Check for spelling errors or missing ONNX suffixes.`;
+            }
+            else if (msg.includes('fetch') || msg.includes('network') || msg.includes('connect') || msg.includes('offline') || msg.includes('getaddrinfo') || msg.includes('timeout')) {
+                errorType = 'Network Connection Failure';
+                diagnostics = 'Failed to connect to Hugging Face Hub to download model files. Subsequent runs will function offline once downloaded.';
+            }
+            else if (msg.includes('cache') || msg.includes('corrupt') || msg.includes('integrity') || msg.includes('checksum')) {
+                errorType = 'Cache Corruption Error';
+                diagnostics = 'The cached model files are corrupt. Try clearing the global model cache directory at ~/.devbrain/models/.';
+            }
+            throw new Error(`[${errorType}] ${error.message}\nFix: ${diagnostics}`);
+        }
+    }
+    async generateEmbedding(text) {
+        const extractor = await this.getPipeline();
+        const output = await extractor(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    async generateEmbeddings(texts) {
+        if (texts.length === 0)
+            return [];
+        const extractor = await this.getPipeline();
+        const results = [];
+        // Batch process sequentially to prevent memory overhead or run in parallel
+        for (const text of texts) {
+            const output = await extractor(text, { pooling: 'mean', normalize: true });
+            results.push(Array.from(output.data));
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=TransformersProvider.js.map

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/engine/dependency.resolver.d.ts

@@ -0,0 +1,12 @@
+export declare class DependencyResolver {
+    private readonly coreConfigs;
+    /**
+     * Resolves the full list of files to analyze based on blast-radius rules.
+     */
+    resolveBlastRadius(changedFiles: string[], projectFiles: string[]): {
+        resolvedFiles: string[];
+        isFullScan: boolean;
+    };
+    private expandControllerBlastRadius;
+    private expandEntityBlastRadius;
+}