devbrain-cli 0.1.0 → 0.3.0

package/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/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/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;
+}

package/node_modules/@devbrain/core/dist/engine/dependency.resolver.js

@@ -0,0 +1,101 @@
+import { basename, extname } from 'node:path';
+export class DependencyResolver {
+    coreConfigs = new Set([
+        'package.json',
+        'tsconfig.json',
+        'docker-compose.yml',
+        '.env.example',
+        'schema.prisma',
+        'pom.xml',
+        'build.gradle',
+        '.gitignore',
+        '.eslintrc.json',
+        '.prettierrc',
+    ]);
+    /**
+     * Resolves the full list of files to analyze based on blast-radius rules.
+     */
+    resolveBlastRadius(changedFiles, projectFiles) {
+        // 1. Check for core configuration changes
+        for (const file of changedFiles) {
+            const name = basename(file);
+            if (this.coreConfigs.has(name) || name.startsWith('.env')) {
+                return { resolvedFiles: projectFiles, isFullScan: true };
+            }
+        }
+        const resolved = new Set();
+        for (const file of changedFiles) {
+            // Add the file itself
+            resolved.add(file);
+            const base = basename(file);
+            const ext = extname(file);
+            const nameWithoutExt = base.slice(0, -ext.length);
+            // Check if it's a source code file (JS, TS, Python, Go, Java, C#, PHP, Ruby, etc.)
+            const isSourceFile = /\.(ts|js|tsx|jsx|py|go|java|cs|php|rb)$/.test(ext);
+            if (!isSourceFile) {
+                continue;
+            }
+            // Check category: Controller
+            if (/controller/i.test(nameWithoutExt)) {
+                const prefix = nameWithoutExt.replace(/controller/i, '').toLowerCase();
+                if (prefix) {
+                    this.expandControllerBlastRadius(prefix, projectFiles, resolved);
+                }
+            }
+            // Check category: Entity / Model
+            else if (/entity/i.test(nameWithoutExt) ||
+                /model/i.test(nameWithoutExt) ||
+                file.includes('/entities/') ||
+                file.includes('/models/') ||
+                // A simple filename in a src/models or entities dir, or standard short names
+                /^[A-Z][a-zA-Z0-9]*$/.test(nameWithoutExt) // e.g. User.ts, Product.ts
+            ) {
+                // Extract prefix (e.g. UserEntity -> User, user.model -> user)
+                let prefix = nameWithoutExt
+                    .replace(/entity/i, '')
+                    .replace(/model/i, '')
+                    .toLowerCase();
+                // If it's a single word capitalized like User.ts, prefix is user
+                if (!prefix) {
+                    prefix = nameWithoutExt.toLowerCase();
+                }
+                this.expandEntityBlastRadius(prefix, projectFiles, resolved);
+            }
+        }
+        // Filter resolved files to ensure they exist in the current project files list
+        const projectFilesSet = new Set(projectFiles);
+        const finalFiles = Array.from(resolved).filter((f) => projectFilesSet.has(f));
+        return { resolvedFiles: finalFiles, isFullScan: false };
+    }
+    expandControllerBlastRadius(prefix, projectFiles, resolved) {
+        // Find related services and routes
+        for (const file of projectFiles) {
+            const base = basename(file).toLowerCase();
+            if (base.includes(prefix)) {
+                if (base.includes('service') || base.includes('route') || base.includes('controller')) {
+                    resolved.add(file);
+                }
+            }
+        }
+    }
+    expandEntityBlastRadius(prefix, projectFiles, resolved) {
+        // Find related repositories, DTOs, services, schemas
+        for (const file of projectFiles) {
+            const base = basename(file).toLowerCase();
+            if (base.includes(prefix)) {
+                if (base.includes('repository') ||
+                    base.includes('dto') ||
+                    base.includes('service') ||
+                    base.includes('entity') ||
+                    base.includes('model') ||
+                    base.includes('schema')) {
+                    resolved.add(file);
+                }
+            }
+            else if (base.includes('schema.prisma') || base.includes('schema.sql')) {
+                resolved.add(file);
+            }
+        }
+    }
+}
+//# sourceMappingURL=dependency.resolver.js.map

package/node_modules/@devbrain/core/dist/engine/history.manager.d.ts

@@ -0,0 +1,24 @@
+import { HistorySchema, CommitHistoryEntry } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class HistoryManager {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly historyPath;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Loads the current history or returns an empty default schema.
+     */
+    loadHistory(): Promise<HistorySchema>;
+    /**
+     * Persists the history schema.
+     */
+    saveHistory(history: HistorySchema): Promise<void>;
+    /**
+     * Adds an entry to commit history and updates lastProcessedCommit.
+     */
+    addCommitEntry(entry: CommitHistoryEntry): Promise<void>;
+    /**
+     * Gets the last processed commit hash.
+     */
+    getLastProcessedCommit(): Promise<string | null>;
+}

package/node_modules/@devbrain/core/dist/engine/history.manager.js

@@ -0,0 +1,64 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, HISTORY_FILE_NAME } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class HistoryManager {
+    cwd;
+    fsService;
+    historyPath;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.historyPath = join(cwd, DEVBRAIN_DIR_NAME, HISTORY_FILE_NAME);
+    }
+    /**
+     * Loads the current history or returns an empty default schema.
+     */
+    async loadHistory() {
+        try {
+            if (await this.fsService.exists(this.historyPath)) {
+                return await this.fsService.readJson(this.historyPath);
+            }
+        }
+        catch {
+            // Fall through to default if reading/parsing fails
+        }
+        return {
+            lastProcessedCommit: '',
+            commits: [],
+        };
+    }
+    /**
+     * Persists the history schema.
+     */
+    async saveHistory(history) {
+        await this.fsService.writeJson(this.historyPath, history);
+    }
+    /**
+     * Adds an entry to commit history and updates lastProcessedCommit.
+     */
+    async addCommitEntry(entry) {
+        const history = await this.loadHistory();
+        // Check if commit already processed to avoid duplicates
+        const index = history.commits.findIndex((c) => c.commitHash === entry.commitHash);
+        if (index !== -1) {
+            history.commits[index] = entry;
+        }
+        else {
+            history.commits.unshift(entry); // Prepend so new commits are first
+        }
+        history.lastProcessedCommit = entry.commitHash;
+        // Limit log entries to keep history.json reasonably sized (e.g. max 500 entries)
+        if (history.commits.length > 500) {
+            history.commits = history.commits.slice(0, 500);
+        }
+        await this.saveHistory(history);
+    }
+    /**
+     * Gets the last processed commit hash.
+     */
+    async getLastProcessedCommit() {
+        const history = await this.loadHistory();
+        return history.lastProcessedCommit || null;
+    }
+}
+//# sourceMappingURL=history.manager.js.map

package/node_modules/@devbrain/core/dist/engine/lock.manager.d.ts

@@ -0,0 +1,21 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class LockManager {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly lockPath;
+    private readonly staleTimeoutMs;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Attempts to acquire the lock. Returns true if acquired, false otherwise.
+     */
+    acquireLock(): Promise<boolean>;
+    /**
+     * Releases the lock by deleting the lock file.
+     */
+    releaseLock(): Promise<void>;
+    /**
+     * Checks if a lock currently exists and is active (not stale).
+     */
+    isLocked(): Promise<boolean>;
+    private checkIfStale;
+}

package/node_modules/@devbrain/core/dist/engine/lock.manager.js

@@ -0,0 +1,89 @@
+import { join } from 'node:path';
+import { unlink, stat } from 'node:fs/promises';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+import { DEVBRAIN_DIR_NAME, LOCK_FILE_NAME } from '@devbrain/shared';
+export class LockManager {
+    cwd;
+    fsService;
+    lockPath;
+    staleTimeoutMs = 10 * 60 * 1000; // 10 minutes
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.lockPath = join(cwd, DEVBRAIN_DIR_NAME, LOCK_FILE_NAME);
+    }
+    /**
+     * Attempts to acquire the lock. Returns true if acquired, false otherwise.
+     */
+    async acquireLock() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                // Check if the lock is stale
+                const isStale = await this.checkIfStale();
+                if (isStale) {
+                    // Release the stale lock
+                    await this.releaseLock();
+                }
+                else {
+                    return false;
+                }
+            }
+            // Write current timestamp
+            const timestamp = Date.now().toString();
+            await this.fsService.writeAtomic(this.lockPath, timestamp);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Releases the lock by deleting the lock file.
+     */
+    async releaseLock() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                await unlink(this.lockPath);
+            }
+        }
+        catch {
+            // Ignore errors during release
+        }
+    }
+    /**
+     * Checks if a lock currently exists and is active (not stale).
+     */
+    async isLocked() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                const isStale = await this.checkIfStale();
+                return !isStale;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async checkIfStale() {
+        try {
+            const stats = await stat(this.lockPath);
+            const fileAgeMs = Date.now() - stats.mtimeMs;
+            if (fileAgeMs > this.staleTimeoutMs) {
+                return true;
+            }
+            // Or read timestamp from file content
+            const content = await this.fsService.read(this.lockPath);
+            const timestamp = parseInt(content.trim(), 10);
+            if (!isNaN(timestamp)) {
+                return Date.now() - timestamp > this.staleTimeoutMs;
+            }
+            return false;
+        }
+        catch {
+            // If we cannot check, assume it is stale to prevent locking out permanently
+            return true;
+        }
+    }
+}
+//# sourceMappingURL=lock.manager.js.map

package/node_modules/@devbrain/core/dist/engine/logger.service.d.ts

@@ -0,0 +1,16 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class LoggerService {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly logDir;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Log a message with a timestamp and log level to a specific file.
+     */
+    log(message: string, level?: string, fileName?: string): Promise<void>;
+    info(message: string, fileName?: string): Promise<void>;
+    success(message: string, fileName?: string): Promise<void>;
+    warn(message: string, fileName?: string): Promise<void>;
+    error(message: string, fileName?: string): Promise<void>;
+    debug(message: string, fileName?: string): Promise<void>;
+}

package/node_modules/@devbrain/core/dist/engine/logger.service.js

@@ -0,0 +1,49 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, LOGS_DIR_NAME } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class LoggerService {
+    cwd;
+    fsService;
+    logDir;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.logDir = join(cwd, DEVBRAIN_DIR_NAME, LOGS_DIR_NAME);
+    }
+    /**
+     * Log a message with a timestamp and log level to a specific file.
+     */
+    async log(message, level = 'INFO', fileName = 'devbrain.log') {
+        try {
+            const timestamp = new Date().toISOString();
+            const logLine = `[${timestamp}] [${level}] ${message}\n`;
+            const targetPath = join(this.logDir, fileName);
+            // Create logs directory if it does not exist
+            if (!(await this.fsService.exists(this.logDir))) {
+                const { mkdir } = await import('node:fs/promises');
+                await mkdir(this.logDir, { recursive: true });
+            }
+            const { appendFile } = await import('node:fs/promises');
+            await appendFile(targetPath, logLine, 'utf8');
+        }
+        catch {
+            // Fallback silently if logging fails to prevent interrupting operations
+        }
+    }
+    async info(message, fileName = 'devbrain.log') {
+        await this.log(message, 'INFO', fileName);
+    }
+    async success(message, fileName = 'devbrain.log') {
+        await this.log(message, 'SUCCESS', fileName);
+    }
+    async warn(message, fileName = 'devbrain.log') {
+        await this.log(message, 'WARN', fileName);
+    }
+    async error(message, fileName = 'devbrain.log') {
+        await this.log(message, 'ERROR', fileName);
+    }
+    async debug(message, fileName = 'devbrain.log') {
+        await this.log(message, 'DEBUG', fileName);
+    }
+}
+//# sourceMappingURL=logger.service.js.map

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

@@ -0,0 +1,30 @@
+import { AggregatedAnalysis, DevBrainConfig } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class MemoryEngine {
+    private readonly cwd;
+    private readonly config;
+    private readonly fsService;
+    private readonly memoryPath;
+    private readonly registry;
+    constructor(cwd: string, config: DevBrainConfig, fsService?: FilesystemService);
+    /**
+     * Loads memory.json or runs a full scan to create it.
+     */
+    loadMemory(): Promise<AggregatedAnalysis>;
+    /**
+     * Persists memory.json.
+     */
+    saveMemory(memory: AggregatedAnalysis): Promise<void>;
+    /**
+     * Run a full project scan.
+     */
+    runFullScan(): Promise<AggregatedAnalysis>;
+    /**
+     * Performs an incremental learning phase on modified/deleted/renamed files.
+     */
+    incrementalLearn(modifiedFiles: string[], deletedFiles: string[], renamedFiles: {
+        from: string;
+        to: string;
+    }[]): Promise<AggregatedAnalysis>;
+    private mergeIncrementalResults;
+}